How to Master AI-Assisted Coding: From Vibe Coding to Agentic Engineering

Introduction

Modern software development is being reshaped by AI, but using it effectively requires more than just typing prompts and hoping for the best. Chris Parsons, a seasoned engineer, has updated his guide on AI-driven coding—now in its third iteration—and his insights cut through the hype. The core lesson? Success hinges not on how fast you can generate code, but on how fast you can tell whether that code is correct. This step-by-step guide distills his advice, along with complementary ideas from Birgitta Böckeler on harness engineering, into a practical workflow. Whether you’re a senior developer worried about becoming a diff reviewer or a junior eager to amplify your output, these steps will help you move from casual “vibe coding” to disciplined, agentic engineering.

How to Master AI-Assisted Coding: From Vibe Coding to Agentic Engineering — Source: martinfowler.com

What You Need

A modern AI coding tool: Recommended options include Claude Code or Codex CLI. These provide the inner harness—the automation and verification layers—that make agentic work efficient.
A version-controlled codebase: Git (or similar) to track changes, run automated tests, and enable rollback.
Automated testing infrastructure: Unit tests, integration tests, type checkers, and static analysis tools. These are your “computational sensors.”
A realistic environment: Staging or local environment where the AI agent can verify its output before asking for human review.
Documentation standards: Define how you’ll document code, prompts, and decisions. “Document ruthlessly” is a key principle.
Time for deliberate practice: Teaching an AI to write good code is a skill—you’ll need to invest in shaping the harness, not just reviewing diffs.

Step-by-Step Guide

Step 1: Understand the Two Mindsets

Before you write a single line with AI, internalize the difference between vibe coding and agentic engineering. Vibe coding means you generate code, largely ignore it, and accept whatever the AI outputs. Agentic engineering, by contrast, treats the AI as a part of a system—you actively shape its output through prompts, tests, and guardrails. Chris Parsons is clear: for professional work, always choose agentic. Your job is not to blindly accept code but to train the AI to produce reliable, verifiable results from the start. This shift in mindset is the foundation of everything that follows.

Step 2: Set Up Your Tool with an Inner Harness

Choose your AI coding tool (Claude Code or Codex CLI are Parsons’ recommendations) and configure it to work within a harness. The harness includes automated checks that run after every change: unit tests, type checkers, linters, and integration tests. This is the “inner harness” that makes the AI self-correcting. For example, set up a Git pre-commit hook that runs tests on any generated code. The goal is to catch errors before the code ever reaches you. As Parsons notes, “Verified” used to mean “read by you.” Now it means “checked by tests, type checkers, automated gates, or by you where your judgement matters.” Configure your harness so the AI verifies against a realistic environment before asking for human input.

Step 3: Keep Changes Small and Documented

One of the enduring fundamentals from Parsons’ original post: keep changes small. Resist the temptation to let the AI generate a massive feature in one go. Instead, break the work into tiny, atomic steps. Each step should have a single, clear purpose. Before generating code, write a brief specification or comment that describes what the change should do. After the AI outputs code, review it against that specification. Document every decision—especially the rationale for accepting or rejecting changes. Why? Because the AI learns from these records. “Document ruthlessly” means you’re building a feedback loop that trains the model to behave better on the next request.

Step 4: Build a Fast Verification Loop

Parsons emphasizes a radical shift: “The game is not ‘how fast can we build’ any more. It is ‘how fast can we tell whether this is right.’” So your next step is to optimize your verification pipeline. Minimize the time between generation and check. Use automated tests that run in seconds. Create a dashboard that shows passing/failing for each change. If a change fails, the AI should be able to retry within the same loop—no human needed. Where human judgment is essential (e.g., architecture decisions), make those checks quick and frictionless. The key metric is how many approaches your team can verify in an afternoon. Not how many you can generate. The team that verifies five in an afternoon beats the team that generates one and waits a week for feedback.

Step 5: Train the AI Through Iterative Feedback

The most valuable skill for a senior engineer in this new paradigm is teaching the AI to write code correctly. You are not just a reviewer; you are a coach. When the AI produces a wrong diff, don’t just fix it—write a prompt that explains the mistake and the correct pattern. Then rerun the generation. Over time, the AI’s output improves because the harness and the prompt history act as training data. Parsons points out that “the way out is to train the AI so the diffs are right the first time.” This compounds: a well-trained AI produces better code with less human correction, freeing you to work on higher-level architecture. Make yourself the person who shapes the harness, not the person who clicks “approve” on diffs.

Step 6: Implement Computational Sensors

Birgitta Böckeler’s work on harness engineering adds a crucial layer: computational sensors. These are automated checks beyond simple tests—static analysis, security scanning, performance benchmarks, and even AI-based code review. Integrate these sensors into your pipeline so that the AI receives immediate feedback not only on correctness but on style, security, and efficiency. For example, if a generated function introduces a SQL injection vulnerability, the static analysis sensor should flag it and the AI should be prompted to rewrite it. This turns your harness into a self-improving system. Böckeler and Chris Ford’s video discusses this in depth; watch it to understand how these sensors make the verification loop even tighter.

Step 7: Shift Your Role from Reviewer to Harness Builder

As a final step, accept that your job description is changing. If you are a senior engineer, you might feel your role is quietly turning into “approving diffs.” The antidote is to make harness building your primary, visible contribution. Invest in better review surfaces, not better prompts. Make feedback unnecessary where possible by having the AI verify before it reaches a human. Automate your own judgment into rules and tests. This role compounds: every improvement to the harness improves all future code generation, while reviewing one diff only improves that one change. Train other developers on your team to think the same way. Pass on the skill of shaping the AI, not just using it.

Tips for Success

Start with a small, non-critical project to practice the workflow before applying it to production systems.
Measure what matters: Track verification time per change, not lines of code generated. Optimize for fast feedback.
Use a changelog or prompt log to see how the AI’s behavior evolves. This helps you identify which training interventions are most effective.
Watch Birgitta Böckeler and Chris Ford’s video on harness engineering for a deeper dive into computational sensors.
Resist the urge to “vibe code” even on quick prototypes—building good habits now will pay off when you scale.
Pair program with the AI: Use your tool like a junior engineer who needs continuous coaching, not an oracle.
Celebrate when your harness catches an error—that means the system is working as designed.

By following these steps, you’ll move from generating code blindly to orchestrating a reliable AI development system. The future of software engineering belongs to those who build the harness, not those who race to ship untested code. Embrace the shift, and watch your productivity and code quality compound.