Summary of #553: All of our tools

Overview of Talk Python to Me #553: All of our tools

This crossover episode from Python Bytes is a personal, highly practical tour of the hosts’ favorite day-to-day developer tools. Michael Kennedy and Calvin Hendricks Parker compare their terminal setups, AI coding workflows, dictation tools, privacy/networking choices, and a few productivity favorites they rely on constantly. The through-line is simple: modern developer work is faster, more comfortable, and more secure when your tools are tailored to how you actually work.

The main theme: build a better personal developer environment

A big idea running through the episode is that your laptop or workstation is the center of your work life, so it’s worth customizing deeply:

• Make the terminal faster and more informative.
• Add AI tools that fit your workflow instead of forcing you into theirs.
• Use local-first and privacy-conscious tools where possible.
• Prefer tools that reduce friction, token waste, and context loss.

Both hosts emphasize that the best tools are the ones that feel invisible once they’re set up.

Terminal-first workflows and developer shells

Calvin’s AI coding stack: Pi + Superpowers

Calvin’s first major pick is a combination of:

• Pi — a terminal-first, open source coding agent harness
• Superpowers — a spec-driven workflow layer

Why he likes them:

• Terminal-first control: Pi gives the user more direct control than many polished IDE-based agent tools.
• Session branching / rewind: He values being able to back up and branch from a previous point in an agent session rather than burning tokens trying to recover.
• Composable extensions: Pi is intentionally minimal and customizable.
• Structured workflow: Superpowers adds brainstorming, planning, execution, verification, review, commit, and merge steps.

He uses this setup for quick personal tools, including one to sync messages from his Mac/phone into a CRM so he can stop copy-pasting.

Michael’s terminal setup: Warp + Oh My Zsh + PLS

Michael’s terminal stack includes:

• Warp — a modern terminal with AI-ish conveniences and collaboration features
• Oh My Zsh — for prompt enhancements and shell productivity
• PLS — a prettier ls with icons and Git awareness

He likes Warp as a fresh terminal experience, but often turns off some of its “smart” features and keeps the shell leaner. Oh My Zsh adds useful context like:

• current Git branch
• dirty state
• active Python virtualenv
• Python version
• branch tab completion

PLS is his “small but delightful” utility for making directory listings easier to scan.

Calvin’s multi-device terminal setup: Kitty + Blink + Mosh + tmux

Calvin’s terminal workflow is built for mobility and consistency:

• Kitty — GPU-accelerated terminal for Mac/Linux/Windows
• tmux — detach/reattach terminal sessions and manage panes
• Blink Shell — iPad/iPhone terminal and SSH/Mosh client
• Mosh — more resilient than SSH on flaky networks

He uses this combination to:

• keep one terminal window with multiple panes/tabs
• jump between Mac, Linux, and iPad with minimal friction
• preserve sessions across travel and unreliable Wi‑Fi
• work from an iPad when he wants to carry less hardware

AI coding tools and workflow philosophy

Claude Code remains a core tool

Michael says Claude Code is still one of his primary AI programming tools, especially when paired with:

• careful prompting
• model selection
• structured workflows
• verification/review steps

He notes that earlier AI coding tools felt like annoying autocomplete, but modern agentic tools are much more useful when they can iterate with tools, tests, and specs.

The value of adversarial review

A useful point from the discussion: the best AI coding workflows now include pushback and verification, not just generation.

• Claude Code is increasingly using subagents and adversarial checks.
• Superpowers adds a review/verification phase.
• The hosts like tools that catch misunderstandings before they become bad code.

The takeaway: agentic coding works best when the system is allowed to challenge itself.

Dictation and transcription tools

MacWhisper for speech-to-text and dictation

Michael and Calvin are both strong believers in dictation, especially for reducing typing strain and speeding up text entry.

MacWhisper is the standout tool discussed:

• local transcription using Whisper models
• can also use newer NVIDIA Parakeet models
• can transcribe YouTube URLs, meetings, and local audio
• supports speaker recognition
• can dictate directly into any text field
• can post-process dictated text with prompts

Michael’s favorite trick:

• map a key to push-to-talk
• speak naturally
• have MacWhisper paste polished text directly into the target app

Calvin uses Claude Haiku for dictation correction, because it’s fast and smart enough to improve formatting and terminology without slowing down the flow.

Handy as the cross-platform alternative

For non-Mac users, Calvin points to Handy, an open source dictation/transcription tool with similar capabilities:

• Whisper and Parakeet support
• works on Mac, Windows, and Linux

Privacy, networking, and remote access

Tailscale for secure access anywhere

Calvin’s privacy/networking pick is Tailscale, which he uses to securely reach home resources from anywhere without exposing ports to the public internet.

Use cases he mentions:

• accessing a local database server from anywhere
• screen sharing into home machines remotely
• securely connecting to internal services
• avoiding risky port forwarding or exposed SSH

The broader point: if a service is meant for your devices only, make it private by default and reachable through an overlay network.

Documentation and publishing tools

Great Docs for polished documentation sites

Michael shares a useful follow-up from another interview: he used Great Docs to turn several of his open source libraries into full documentation sites.

Benefits he highlights:

• docs that go beyond a GitHub README
• changelog support
• API reference pages
• source links that jump to implementation
• LLM-friendly “skills” and usage instructions

He especially likes that this makes libraries more accessible to both humans and AI tools.

Markdown viewing and editing

The episode also mentions a Mac-focused Markdown tool:

• Typora as a comparison point
• a newer Mac markdown viewer/editor called Telescopo in the transcript

The shared theme: good docs should be easy to read, easy to browse, and pleasant to work with.

Other notable tools and ideas

Starship prompt

A cross-shell prompt framework that makes terminals feel polished and informative, with:

• Git status
• OS-specific icons
• fast Rust-based performance
• consistent appearance across systems

Command Book

Michael’s own tool for managing long-running tasks outside the terminal, so the terminal stays focused on terminal work.

Local-first computing

A recurring theme is that local hardware is becoming more valuable again:

• stronger Macs and Linux boxes
• local AI models
• local transcription
• self-hosted services
• private access via Tailscale

Key takeaways

• Customize your terminal: the default shell experience leaves a lot of productivity on the table.
• Use agentic AI with structure: branching, review, and specs matter more than raw generation.
• Dictation is underrated: tools like MacWhisper can reduce typing strain and speed up writing.
• Prefer private connectivity: Tailscale makes remote access much safer and easier.
• Think in systems, not apps: the hosts are building cohesive workflows, not just collecting tools.

Bottom line

This episode is really a love letter to carefully chosen tools that remove friction. Whether it’s a terminal harness for AI coding, a better shell prompt, transcription software, or secure remote access, the hosts consistently favor tools that are:

• fast
• local-first when possible
• highly customizable
• well suited to real-world developer workflows

If you like practical dev tooling, terminal setups, or agentic AI workflows, this episode is packed with ideas worth stealing.