01
Foundation Sprint
$12,000 • 2 weeks
Best when your team uses AI coding tools unevenly and you want a senior review of the workflow plus one concrete shipped piece, like a rollout playbook or shared conventions.
AI-Native Engineering
Your team has AI coding agents. Now it needs a practice around them.
I help engineering teams build the practice around AI coding agents: how work gets shaped for an agent, what context the agent can reach, how its output is verified and reviewed, and how changes ship.
It is the workflow I run every day across Claude Code, Codex, and Pi, and I document it in public. With a team, the work happens in your codebase, against your tickets, with your conventions.
Fit
Who This Is For
This page is for engineering teams that already use AI coding tools and want consistent results across the team, not just from one or two power users.
- A few engineers get strong results from agents, the rest of the team does not, and nobody can say exactly why.
- Agent-written changes are reaching pull requests faster than the team can review them with confidence.
- Your agents work from the prompt and the repository alone, without the tickets, errors, and decisions that live elsewhere.
- You are standardizing on Claude Code, Codex, or a mix, and want conventions that hold across tools.
- You want a senior engineer inside the codebase setting this up, not a slide deck about it.
Problems
Where Teams Usually Get Stuck
Agents start building before the problem is understood
Work reaches an agent as a one-line ticket. The agent fills the gaps with guesses, and the time it saved goes into rework. Shaping the problem and the spec first is what lets an agent work on its own.
The agent cannot see the context that matters
Tickets, production errors, meeting notes, and team docs live outside the repository. Without access to them, the agent works from an incomplete picture and engineers paste context in by hand.
Nothing proves the change works
"It compiles" and the agent's own summary are not verification. Without a way for agents to run the feature and check real behavior, every change needs a human to work out whether it does what it claims.
Review becomes the bottleneck
More changes arrive, and each one is reviewed the same way as before. Review has to scale with output: focused reviewers, findings checked against the code before anyone reads them, and a loop back to the implementer.
Every engineer has a private setup
Instruction files, skills, and MCP servers live on individual laptops. What works for one engineer never becomes the team default, and every new hire starts from zero.
How I help
How I Help
The work follows the loop I use myself: shape, build, review, ship. We start with the stage that is weakest for your team, which is usually shaping or verification.
01
Workflow Assessment
Review how work moves from ticket to merged pull request today: where agents help, where they create rework, and which stage of the loop to fix first. You leave with a written assessment and a prioritized path.
02
Shaping Practice
Set up how the team turns a problem into a spec and a set of issues an agent can pick up, with decisions recorded and a shared vocabulary for the domain.
03
Context Wiring
Connect agents to the systems that hold the context, such as your issue tracker, error monitoring, meeting notes, and team docs, through MCP servers or CLIs that work across agents.
04
Verification and Review
Give agents a way to prove their changes against the running app, and build a review loop where every reviewer finding is verified against the code before it reaches a human.
05
Shared Conventions and Skills
Move instruction files, skills, and MCP configuration out of individual setups and into the repository, so the team's best workflow becomes the default.
06
Working Sessions on Your Codebase
Hands-on sessions where we run the loop on real issues in your repository, so the practice is built on your code instead of a demo project.
Engagements
A Focused Starting Point
AI-native engineering runs through the same engagements as the rest of my consulting. Most teams start with a Foundation Sprint: two weeks to look at how the team works with agents today, find the highest-leverage gap, and ship one foundation piece, such as a team rollout playbook or a shared skills and conventions setup. If there is more to do, the Sprint can convert into an ongoing Production AI retainer.
02
Production AI Retainer
$15k-$60k/month
Best when AI-native engineering is part of a broader production AI workstream and you need ongoing judgment plus implementation capacity in your codebase.
Background
Why Me
- 15+ years building production software, including time as a Staff Engineer at Shopify and as CTO at Buoy Software, where I grew the engineering team from 0 to 50+.
- Shipped FDA-cleared medical device software, where knowing what to verify and what to prove was the job.
- I run this workflow daily across Claude Code, Codex, and Pi, and document it in public.
- The skills behind it, including
team-code-review,conventional-commits, andstacked-prs, are open source in my agent-skills library. You can read the work before we talk. - A bias toward practices and written artifacts your team owns after the engagement ends, not a dependency on me.
From the clients
What Clients Say
“He quickly understood where we were with AI tooling and gave us immediately actionable advice, not generic frameworks…
He identified gaps we hadn't considered, walked us through how he architects agent loops in production, and helped us think through our product-level agent strategy without over-engineering it.”
Will Wallace
Co-Founder, Rebolt
Related work
How I Work With Agents
Public writing on the workflow and the thinking behind this page.
- ArticleMy Agentic Coding Workflow: Claude Code, Codex, and PiThe shape, build, review, ship loop, the context tools behind it, and how verification lets me hand off more of the work.
- ArticleOne Skills Library for Every Coding AgentHow I keep skills in one library that installs across coding agents, and why I removed the ones I no longer use.
- ArticleHarness Engineering: The 4 Levers Behind Almost Every Agent FailureContext, tools, loop, and governance: a fast way to find which part of the harness broke.
- ArticleFour Dimensions of Agent-Ready Codebase DesignThe codebase patterns that account for most of the gap between noisy and reliable agent output.
FAQ
Common Questions
What is AI-native engineering?
It is the practice of building software with AI coding agents as part of the everyday workflow: shaping work so an agent can pick it up, giving agents the context they need, verifying and reviewing what they produce, and shipping it through the same discipline as any other change. The tools change every few months. The practice carries over.
Which tools do you work with?
I use Claude Code, Codex, and Pi daily and pick between them based on the work. Shaping, context, verification, and review carry over between harnesses, so I work with what your team already uses rather than asking you to switch.
Do you still offer 1:1 AI-native engineering coaching?
No. The individual coaching program is retired. AI-native engineering is now team work, delivered through Foundation Sprints and retainers. If you are working on your own practice, the workflow post and my open-source agent-skills library are the best place to start.
Can you write code with our team?
Yes. Foundation Sprints and retainers can include hands-on implementation in your codebase. Practices stick when they are built against real issues in your repository, not described from the side.
What if we're not ready for an engagement?
Run the free Codebase Readiness Assessment. It is an agent skill that scores your repository for AI-agent readiness and gives you a prioritized improvement roadmap.
Want your team working this way?
Book a free 30-minute intro call. We will talk through how your team works with agents today, where the friction is, and whether a Foundation Sprint or retainer is the right next step.
No pitch deck. No pressure. Just a technical conversation about how your team ships.