The post lays out a staged workflow for AI-assisted software development that moves from simple autocomplete and chat help toward a more agentic setup. Specs get written up front, tasks are split across worktrees or sandboxes, agents implement in parallel, and the human shifts from writing code to planning, steering, and approving pull requests. The pitch is not that AI writes perfect software on its own. It is that enough process can let one developer supervise far more code generation than they could produce directly.
Most of the useful signal landed on a narrower claim. LLMs work well when the job is local, repetitive, or mechanically transformed from a known example. They are good at framework glue, migrations, repetitive document generation, and filling in components inside an already-decided structure. People using them successfully kept saying the same thing in plainer terms: stay in the loop, keep scope tight, and give the model a strong harness. Storybooks, component tests,
end-to-end tests, protected environments, and close review were not optional extras. They were the reason the workflow held together at all.
Where the enthusiasm ran into a wall was review and architecture. Several people said the labor did not disappear. It moved. Large AI-generated diffs are exhausting to review, and proper review often means reconstructing the solution yourself anyway. That makes the promised productivity gains much weaker on work that is ambiguous, exploratory, or architecture-heavy. The sharpest conclusion was that current agentic coding is best understood as supervised batch generation for well-bounded tasks, not a path to removing engineering judgment. The more a problem depends on tradeoffs, domain knowledge, or keeping a long-lived codebase coherent, the more the human remains the scarce resource.
thoughtfultechnologist.com