In the fast-moving world of artificial intelligence and software development, few updates have captured the community's attention quite like Chris Parsons' third revision of his practical guide on using AI to code. This isn't just another theoretical treatise—it's a grounded, detailed walkthrough that resonates with the best advice floating around today. Parsons doesn't just tell you what tools to use; he shows you how to think about the process, making his guide a must-read overview of where AI-assisted development stands now.
But the conversation doesn't stop there. Complementary thinkers like Birgitta Böckeler have taken the next step, diving into what she calls 'Harness Engineering'—the systematic scaffolding that makes agentic AI actually reliable. Together, these ideas form a new playbook for developers who want to stay ahead.
Core Principles That Stand the Test of Time
Parsons' guide, first written in March 2025 and updated twice since, has become a central reference point in the AI engineering community. Its foundational advice remains rock-solid: keep changes small, build guardrails, document ruthlessly, and ensure every change is verified before shipping. But one element has evolved significantly with the sheer volume of AI-generated code. Where 'verified' once meant 'read by you,' it now means checked by tests, type checkers, automated gates, or—where human judgment is critical—by you. The verification still happens, but it no longer always takes place in your head.
Vibe Coding versus Agentic Engineering
Parsons, like Simon Willison, draws a sharp line between 'vibe coding' (where you don't look at or care about the code) and true agentic engineering. He sees the former as a dead end for serious work. Instead, he recommends tools like Claude Code or Codex CLI, not just for their code generation abilities, but for the 'inner harness' they provide—a critical layer that helps the developer maintain control and quality.
That harness is a key differentiator. It's not about writing perfect prompts; it's about building a system where the AI operates inside safe boundaries and its outputs are continuously validated.
The Verification Economy: Speed Through Confidence
Perhaps the most provocative insight from Parsons' update is his redefinition of competitive advantage in software development. He writes:
"A team that can generate five approaches and verify all five in an afternoon will outpace a team that generates one and waits a week for feedback. The game is not 'how fast can we build' any more. It is 'how fast can we tell whether this is right'."
This shifts the entire investment strategy. Instead of obsessing over better prompts, developers should build better review surfaces. Where possible, have the agent verify against a realistic environment before it asks a human. Where feedback is unavoidable, make it instant. The goal is to compress the feedback loop from days to minutes—and that changes everything about how we organize teams and tools.
The Programmer's New Role: From Code Writer to AI Trainer
A recurring theme in the current wave of AI development is the shifting identity of the programmer. Parsons argues that the core job is no longer writing code, but training the AI to write software properly. The most skilled agentic programmers are those who can pass on that skill to other developers. This is a fundamentally different career trajectory.
For senior engineers worried that their role is turning into 'approving diffs'—Parsons has a frank response: it is. But the way out is to train the AI so the diffs are right the first time, making yourself the person who shapes the harness. That work compounds; reviewing never does. The visible metric becomes the quality of the harness and the speed of the team, not the number of lines written.
Harness Engineering: A Systematic Approach
Building on these ideas, Birgitta Böckeler published a superb article on Harness Engineering early this month—a piece that attracted extraordinary traffic and sparked a follow-up video discussion with Chris Ford. In that conversation, they zero in on the role of computational sensors in the harness: static analysis, tests, and other automated checks that provide constant feedback.
The core insight is that large language models (LLMs) are excellent at exploration—generating many candidate solutions—but poor at verification. A harness flips the script: it lets the AI explore freely within a controlled environment, automatically validating each candidate before human eyes ever see it. This is not just an efficiency gain; it's a fundamental shift in how software gets built.
For developers looking to adopt these practices, the recommendations are clear:
- Invest in automated verification—tests, linters, type checkers, and integration environments that can run without human intervention.
- Choose agentic tools with strong inner harnesses—like Claude Code or Codex CLI—that help maintain quality.
- Train your AI incrementally, documenting patterns and rules so the generated code improves over time.
- Shift your personal metric from code output to system improvement: how well you design the harness that shapes the AI.
Conclusion: A New Development Ethos
The messages from Parsons, Böckeler, and others converge on a single theme: the future of AI-assisted development is not about coding faster, but about verifying faster. The programmers who will thrive are those who design the systems—the harnesses, the tests, the review surfaces—that make AI reliable. They shift from being the bottleneck to being the enabler. And in doing so, they unlock a pace of development that was impossible just a year ago.
If you're a developer, the real question isn't 'Which AI tool should I use?' It's 'How do I build a harness that lets this tool shine?' Start with the core principles, invest in verification, and remember: the best code is the code that's already been validated before you read it.