Introduction
The landscape of software development has shifted dramatically. Gone are the days when simply typing prompts and accepting code blindly—dubbed vibe coding—was enough. Today's top developers use AI as an intelligent collaborator, a practice known as agentic engineering. This guide, inspired by the latest insights from Chris Parsons and industry experts like Birgitta Böckeler, provides a structured, step-by-step approach to using AI for coding effectively. You'll learn how to move beyond generating code to verifying it, building robust harnesses, and training AI to produce reliable output. By following these steps, you'll transform from a passive code reviewer into an active engineer who shapes the AI's behavior, ensuring every change is correct, fast, and scalable.
What You Need
- An AI coding tool such as Claude Code or Codex CLI (recommended for their integrated harness support)
- A development environment with version control (e.g., Git)
- Automated testing framework (unit, integration, or end-to-end)
- Static analysis tools (linters, type checkers like TypeScript or mypy)
- Continuous integration (CI) pipeline to run tests automatically
- Basic understanding of software development principles and your codebase
- A willingness to invest in infrastructure over prompt tweaking
Step-by-Step Guide
Step 1: Adopt the Agentic Mindset
Before you write any code, shift your mental model. Vibe coding—where you accept AI output without scrutiny—leads to fragile, unverified code. Instead, adopt an agentic mindset: treat the AI as a junior developer you are training. You remain accountable for every line. Understand that your primary job is not to produce code but to verify correctness and shape the AI's behavior. This mindset is the foundation for all subsequent steps.
Step 2: Keep Changes Small and Incremental
Break down tasks into tiny, atomic units. Each change should be small enough that you can review it manually if needed. For example, instead of asking the AI to build an entire feature in one go, ask it to write a single function, then a test, then integrate it. Small changes are easier to verify, debug, and revert. This principle echoes Chris Parsons' original advice: “keep changes small”. It also reduces the risk of the AI generating too much untested code at once.
Step 3: Build Guardrails with Automated Verification
Verification is the heart of agentic engineering. You cannot rely solely on manual review once AI throughput increases. Instead, set up automated gates: tests, type checkers, linters, and CI pipelines. Every code change must pass these checks before it’s merged. As Parsons notes, “Verified” used to mean “read by you”; now it means “checked by tests, by type checkers, by automated gates, or by you where your judgement matters”. Invest in building these guardrails first—they are your safety net.
Step 4: Document Ruthlessly
Good documentation is not just for humans—it's for the AI. When you write clear comments, function descriptions, and commit messages, you provide context that helps the AI generate code that aligns with your intent. Document your architecture, coding conventions, and edge cases. Ruthless documentation reduces ambiguity and makes the AI’s output more predictable. It also serves as a reference for other developers (and your future self).
Step 5: Train the AI on Your Codebase
The AI is only as good as the context you give it. Use your tool’s features to provide relevant code snippets, style guidelines, and examples. For instance, if you have a specific pattern for error handling, show the AI an example. Over time, the AI learns to write code that fits your codebase. This training is a key role of skilled developers: “the most important thing skilled agentic programmers can do is pass that skill onto other developers”—including the AI itself. By training the AI, you make its diffs correct the first time, reducing your review burden.
Step 6: Optimize for Fast Feedback
Speed of verification is now the competitive advantage. 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. Invest in review surfaces, not prompts. Make feedback unnecessary where you can by having the agent verify against a realistic environment before it asks a human. Make feedback instant where you cannot. This means setting up fast CI pipelines, using incremental testing, and leveraging AI to self-check its output.
Step 7: Become a Harness Engineer
Birgitta Böckeler's concept of harness engineering is central to this workflow. The harness encompasses all the computational sensors—static analysis, tests, type checks—that the AI uses to validate its own output. Your job is to build and maintain this harness. It should be so effective that the AI can test its own code before submitting it to you. As a harness engineer, you shape the environment in which the AI operates, compounding your impact far beyond reviewing individual diffs. As Chris Ford discusses in the video with Böckeler, computational sensors catch errors early and reduce human load.
Step 8: Mentor Other Developers
Finally, pass on your skills. Teach your team how to set up harnesses, write tests, and train the AI. Make the work of shaping the AI visible and measurable. As Parsons states, “the way out is to train the AI so the diffs are right the first time, to make yourself the person on the team who shapes the harness, and to make that work the visible thing you are measured on.” This role compounds—it makes the entire team more productive and ensures that the benefits of agentic engineering scale.
Tips for Success
- Embrace the shift from producer to verifier. Your value now lies in how quickly you can determine if code is correct, not how quickly you can write it.
- Automate everything you can. If a verification step can be scripted, script it. The more automated gates, the safer you are.
- Use computational sensors. Static analysis and tests are your best friends. They catch issues the AI might overlook.
- Keep learning. The AI landscape evolves fast. Revisit your harness, tools, and processes regularly.
- Stay engaged. Even with automation, your judgment is irreplaceable for nuanced decisions. Don't become a passive diff approver—become a harness architect.
By following these steps, you can harness the power of AI without sacrificing quality. The game is no longer “how fast can we build” but “how fast can we tell whether this is right.” Invest in that speed, and you’ll stay ahead.