FAQ

What a skeptical programmer or an executive asks.

Is this just XP?

No. XP's values stay, and its twenty-nine rules are rewritten for teams that work with coding agents.

One rule didn't survive. Rule 22, "Only one pair integrates code at a time," is retired: "Machines took this one over. Merge queues and CI serialize integration, so nobody takes turns anymore."

See the rules, 1999 next to 2026.

Isn't this vibe coding with a methodology name?

No. Vibe coding is one of the two failures IMP answers.

The new wild west of no-software-process-development is nothing other than vibe coding.

IMP's response is that our rigor doesn't depend on belief. The rules run in machines: mutation gates, executable contracts, merge checks, guardrails on every change. A name can't drain rigor that's enforced by a build.

Does it hold up where real money is at stake?

The evidence so far comes from Agora, ZAR's agent orchestration platform. In September 2026 Obie deleted three of its components and had Claude Code rebuild each one from a written Contract.

Writing the Contract for the reboot code exposed a bug in production. A Stop clicked while a Reboot was under way was getting lost. The new obligation went into the Contract first, and three examples went red against the unchanged code. Then the code changed to match.

Two timelines of an agent reboot. Before the fix, a Stop clicked during the reboot is lost and the agent starts again. After the fix, the Stop wins and the agent stays stopped. Before reboot under way Reboot Stop clicked starts anyway After Reboot Stop clicked stays stopped
The bug the Contract exposed. A Stop clicked while a Reboot was under way used to be lost. Now the Stop wins.

The experiments are written up on the case study page.

Do we still review code?

Only where the blast radius calls for it.

XP said all code must pass all tests before release. IMP says green merges itself. Our long-term goal is to get rid of human code review altogether. The blast radius of your PR is how you decide how aggressive to get with that goal today. As much as possible should ship, land and deploy based on automated checks and adversarial model review. Save human eyes for reviews guarding against catastrophic risks.

See rule 27.

Do we still write tests?

Yes, and each one has to earn its place.

XP said all code must have unit tests. IMP says not all code needs unit tests, because every test (unit or otherwise) has to prove that it's worth keeping and burning CPU cycles on. Agents will happily write thousands of automated tests along with your code. Imps run all automated tests through a kill matrix using mutation testing, and keep a test only if it catches something no other test catches.

A kill matrix: six tests against eight mutants. Tests 3 and 5 catch only what other tests already catch. mutants test 1 test 2 test 3 test 4 test 5 test 6
A kill matrix. Each column is the code broken on purpose in one small way, and a dot means that test catches it. Take away tests 3 and 5 and every mutant shown is still caught.

See rule 26.

XP said write the unit test first. IMP says agree on the Contract. As you and the agent work out what the feature must do, the agent writes each obligation into the Contract, and you make sure it's complete on the exhale. The most impish thing you can do is to make the Contract executable.

See rule 20.

Is the Contract a spec?

It's a spec that lives in the source code, and the aim is for a machine to run it.

In IMP the metaphor/mental model gets written down in the source code. We call it the Contract. It's the team's comprehensive description of what the software must do, in a form a team can collaborate on and maintain. That includes the non-functional obligations nobody writes down.

The Contract isn't user stories, redux. Entire systems can get regenerated in an afternoon now. (Ruby on Rails apps get rewritten as Rust!) We only regenerate when it's worth doing, but we keep everything regenerable, the way you run a fire drill without burning the building down. If you can't rebuild a component from its Contract, the Contract is missing something. The Contract is now the thing most worth protecting. It should be convention-oriented and structured language, and it should be versioned, and if you work in a team, you probably want to make it the main focus of your "code reviews" well after everyone stops looking at implementation code.

More in the intro.

What happens when an agent breaks production?

You roll back, then you fix the Contract before you fix the code.

Claude can set up canary deployments for you without breaking a sweat. It can also hotfix or rollback almost any bad release almost instantly.

When you find a real bug, the Contract was missing something. Have your agent add the missing obligation to the Contract first, and make it executable. Then fix the code. Every bug leaves the Contract stronger.

See rule 27 and rule 28.

We run Scrum. Where does this fit?

It replaces the sprint.

We believe that Scrum sprints let teams expand the work to fit the deadline. We think that's exactly the wrong kind of way to enforce commitments in the age of AI.

IMP has no timeboxed iterations. Work flows pull request by pull request, and every green merge is an increment. Rework still happens, inside every pull request. Once a week the whole company holds a showcase, and the rule is presenters can only show something that they've actually finished.

See rule 4.

With no iterations, how do I know when something will ship?

You get a forecast once the unknowns are gone.

Long projects climb a hill. Until you reach the top, you're still turning unknowns into knowns, and nobody should pretend to know the date. At the top, whoever committed to deliver the work provides a deadline that they believe is fair and honest. Management holds them to the date.

See rule 2.

Agents ship a flood of small PRs. How do we know quality isn't collapsing?

Count the defects that reach production. Small PRs can't inflate that number, so it's the one to watch.

Most dashboards count every PR labeled as a fix, and agents ship in small steps. Say an agent sends twelve PRs tuning a checkout screen that's still behind a feature flag. Counted the usual way, that's twelve bug fixes, and quality looks like it fell off a cliff in a week where no customer hit a single problem.

So in IMP, fix: is reserved for a defect in code that's live in production. The twelve tuning PRs are labeled refine:. If a customer then sees a wrong total at checkout, that's one fix, and your fix count now tracks what users run into.

Two machines keep that count low. Before anything merges, the Contract has to pass, and mutation testing has to show the tests catch broken code. And every production defect adds its missing obligation to the Contract, so the same bug can't come back quietly.

See rule 9 on labels, rule 26 on mutation testing and rule 28 on bugs.

What about pairing with people?

Pair people up when there's a decision to make that neither of them should make alone.

XP put two people at one keyboard for every line of production code. Agents do the typing now, and everyone pairs with Claude all day, every day (rule 21). A second person watching the agent type adds little.

Two people still beat one on the problem and the options for solving it. When neither person is senior enough to make the call alone, and they'd rather not leave it to the agent to pick, they talk it through together before anyone decides. That's how we pair at ZAR. Two people look at the problem together, argue through the options until they agree, and then let the agent build it.

The rest of the time people work in public channels, where anyone can see the work and join in (rule 6).

Is this for solo developers?

It's built for teams.

IMP is for teams doing professional software engineering, the kind of team that wants to pick a method, adopt it as its way of working, and tell the rest of the company, "This is how we work now." Individuals can take pieces of it, but it's intended for teams.

Obie put it this way on the Ruby on Rails Podcast, recorded at Rails World in 2026: "everyone who pays for software is not going to magically just turn into a one person software shop."

What's left for programmers who love the craft?

Guardrails.

Platform and infrastructure work is where the technical frontier lives now. If you want to stay deeply technical, working on hardcore nerdy stuff, then you're going to have to embrace working on ever-improving guardrails. That means harnesses, agent orchestration, knowledge graphs, and intelligent event-based nervous systems. Auto-optimizing loops and evals.

A guardrail is software, and building one is programming.

What do we do first on Monday?

Write down what you're building this week, and give your agent the primer.

Before you commit to a project, write down your success criteria for it and post that somewhere that the rest of your team can refer to it. Then call your shot: one big project, one demoable vertical slice by Friday.

If you work with a coding agent, give it the primer for agents.

See rule 1 and rule 2.