Introduction
Artificial intelligence is transforming software development, but using it effectively requires more than just typing prompts. Chris Parsons's updated guide—endorsed by Simon Willison and others—provides a concrete, evidence-based approach. This step-by-step guide distills the core practices: keeping changes small, building verification pipelines, documenting ruthlessly, and training AI to produce correct code. Unlike 'vibe coding,' where you ignore the output, agentic engineering demands deliberate oversight and automation. By following these steps, you'll learn how to accelerate development without sacrificing quality.
What You Need
- AI coding tool – Claude Code, Codex CLI, or a similar agentic tool (not just a chat interface)
- Version control – Git or equivalent, with a branch-per-feature workflow
- Automated testing framework – Unit tests, integration tests, and type checkers (e.g., pytest, TypeScript, ESLint)
- CI/CD pipeline – Jenkins, GitHub Actions, or any system that runs tests on every push
- Documentation platform – Wiki, Markdown files, or an internal knowledge base
- Code review process – Pull request templates and review checklists
- Monitoring and logging – To catch issues in production
- A learning mindset – Be ready to iterate on your workflow
Step-by-Step Instructions
Step 1: Choose Your Agentic Tool and Set Up a Secure Inner Harness
Not all AI coding tools are equal. For agentic engineering, you need a tool that can reason about your codebase, generate changes across multiple files, and run commands. Claude Code and Codex CLI are recommended because they provide an inner harness—a controlled environment where the AI can propose and test changes without affecting production. Configure the tool to work within a sandbox: restrict file access, limit internet connectivity, and define clear boundaries. This is your first guardrail.
Step 2: Establish a Verification-First Pipeline
Parsons's key insight: the game has shifted from 'how fast can we build?' to 'how fast can we tell whether this is right?' Invest in review surfaces, not better prompts. Set up automated gates:
- Type checkers (e.g., mypy, TypeScript compiler)
- Linters (e.g., ESLint, pylint)
- Unit tests that run on every commit
- Integration tests that simulate real environments
- Visual regression tests if UI is involved
These automated gates run before the code reaches a human reviewer. The AI agent should verify its own output against this harness—if tests fail, it must iterate.
Step 3: Keep Changes Small and Atomic
Large diffs are harder to review and more likely to introduce bugs. Break work into small, logical changes. A good rule: a single change should take the AI no more than a few minutes to generate and verify. Use feature flags to merge incomplete work without affecting users. This way, you maintain a steady flow of small, safe updates.
Step 4: Document Ruthlessly—Both Code and Process
Documentation is not optional. Every function, every decision, every change made by the AI should be recorded. Use:
- Inline comments for non-obvious logic
- README files for each module
- A changelog that tracks AI-generated updates
- Prompt templates and guidelines for the team
The AI can generate docs automatically; enforce that as part of the pull request. A well-documented codebase reduces mistakes and accelerates onboarding of new developers.
Step 5: Build Guardrails—Automated and Human
Guardrails are the safety net. They include:
- Automated: tests, type checking, code reviews scripts, dependency scanners
- Human: code reviews for critical paths, security audits, deploy freezes
- Process: checklists, approval gates, rollback plans
Parsons notes that 'verified' used to mean 'read by you.' Now it means checked by tests, type checkers, automated gates, or by you where your judgment matters. Make sure every change passes at least one automated check before merging.
Step 6: Train the AI, Not Just the Developers
The most important role of a senior engineer is training the AI to produce correct code. This means:
- Crafting clear, specific prompts that include context and constraints
- Feeding the AI examples of good code from your codebase
- Reviewing and correcting AI output, then logging those corrections
- Using the same techniques to mentor junior developers
As Parsons says, if you are a senior engineer worried about becoming a diff approver, the way out is to train the AI so the diffs are right the first time. That work compounds—it makes you the person who shapes the harness.
Step 7: Generate Multiple Approaches and Verify in Parallel
Don't settle for the first solution the AI produces. Prompt it to generate two or three different approaches for the same feature. Then run your verification pipeline on all of them simultaneously. 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 speed of verification is now the bottleneck.
Step 8: Create a Culture of Feedback and Iteration
Make feedback loops instant. Where you can, have the agent verify against a realistic environment before it asks a human. Where you cannot, provide a quick way for humans to review. Use dashboards to show test results, code coverage, and review times. Celebrate improvements in the harness. Regularly revisit your process: what would make verification faster? What guardrails are missing?
Tips for Success
- Start small. Pick one feature or one microservice to pilot your new workflow before rolling out to the whole codebase.
- Embrace the harness. Follow Birgitta Böckeler's work on Harness Engineering—it's the underpinning of this approach. Her video discussion with Chris Ford explores the role of computational sensors (static analysis, tests) in detail.
- Measure what matters. Track cycle time, verification speed, and defect rate. Use these metrics to guide improvements.
- Don't forget human judgment. Some decisions—like architecture, security boundaries, and user experience—still require a human eye. Reserve time for those reviews.
- Iterate on your prompts. Treat prompts like code. Version them, review them, and update them as you learn.
- Share knowledge. The most skilled agentic programmers pass their skills to other developers. Write internal guides, host lunch-and-learns, and document your lessons.
By following these steps, you'll move from 'vibe coding' to a disciplined, agentic engineering practice that delivers quality software faster. The future belongs to teams that can verify faster than they can generate—start building your verification pipeline today.