The "In Progress" Column is a Lie
Early-stage startups can move fast just slinging prompts at greenfield code. But for established engineering teams with distributed systems, real compliance, and two-approval PR gates, AI adoption has hit a weird plateau.
We gave everyone coding agents and CLI tools, but we never redesigned our SDLC around them.
The result is a strange modern friction. Nobody on our team is manually writing code anymore. Yet an engineer still picks up a Jira ticket, moves it to “In Progress”, and spends hours in an interactive terminal session. They discover edge cases on the fly, debate schemas with a chat model, and baby-sit the agent while it iterates.
We stopped typing syntax, but we are still coupling human hours directly to the implementation phase.
Over the last few weeks, I’ve been experimenting with a different model: completely isolating the only part of this pipeline that is truly automatable—the translation of a hardened spec into code.
That translation doesn’t require an engineer watching a terminal scroll. It should be a detached, headless background build step.
To make that work, the entire team workflow flips:
- Review moves upstream: Before a task is ever touched, an agent interrogates the ticket—flagging missing error states, unhandled status codes, and boundary conflicts. Human engineers review and approve the spec itself, marking it “Ready to Implement” before a single line of code exists.
- “In Progress” becomes a machine trigger: Moving the ticket doesn’t assign an engineer to run a CLI tool. It triggers a headless background pipeline that takes the spec, implements the code, and opens a pull request.
- High-level architectural review: Engineers only re-enter at the PR stage. With two approvals required to merge, their role isn’t line-by-line proofreading—linters and tests handle that. Their job is evaluating the mental model: does this organization make sense, and does it respect our system boundaries?
Interactive prompting in a terminal was just the transitional phase. The real jump happens when implementation becomes an asynchronous background job, and engineers return to where human judgment actually belongs: defining intent before the build, and evaluating architecture after it’s done.