After migrating a payment system with AI, I noticed a pattern in what worked. Not something I planned — it emerged from doing it responsibly.

This is that framework.

The Two Layers

There are two layers to responsible AI development:

1. The Phases — what you do (the workflow)
2. The Practices — how you think (the discipline)

The phases alone aren’t enough. You can follow the workflow and still produce garbage. The practices are what make it work.

The Six Phases

Phase 1: Map the Territory

Use AI to understand what you’re working with. Get the lay of the land.

But here’s the catch: verify against reality. AI gives you the most plausible explanation, not necessarily the correct one. Check the database. Read the logs. Talk to people who built it.

Phase 2: Design the Target

Generate architectural options. Let AI show you different approaches with different tradeoffs.

But you use judgment to decide. Evaluate against principles you know are true: testability, debuggability, extensibility. Your accumulated knowledge matters here, even in unfamiliar territory.

Phase 3: Build Structure First

Build the clean version. Just the happy path. Prove the architecture works before adding complexity.

This becomes your framework for understanding everything else.

Phase 4: Reintroduce Complexity

Now add the edge cases. The weird legacy behavior. The real-world messiness.

But do it systematically. For each piece of complexity, ask: where does this fit? The clean structure gives you a place for everything.

Not all complexity is worth keeping. Some legacy behavior was solving problems that don’t exist anymore. You decide what matters.

Phase 5: Verify Behavior

Test that the new system matches the old one where it should. Find the differences. Make conscious decisions about each one.

AI can generate tests. But only you can validate they test what actually matters.

Phase 6: Deploy Carefully

Staged rollouts. Feature flags. Monitoring. Limit the blast radius.

This isn’t AI-specific. It’s just good engineering. But it matters more when AI helped write the code.

The Five Practices

The phases tell you what to do. The practices tell you how to think.

At every phase, cycle through all five:

1. Exploring

Use AI to understand, generate options, see possibilities. This is where AI shines — rapid exploration of solution space.

2. Verifying

Check against reality. Does the explanation match the actual behavior? Does the code do what it claims? Never trust without verification.

3. Reflecting

Can you explain this? Do you understand why it works? If you couldn’t describe it to a colleague, you don’t understand it well enough.

4. Critiquing

Does this actually solve the problem? Is this the right approach? Challenge the AI’s suggestions. Challenge your own assumptions.

5. Intuiting

What does your experience tell you? That nagging feeling that something’s off — don’t ignore it. Your accumulated judgment is valuable.

How They Work Together

Here’s the key insight: at every phase, you cycle through all practices.

When mapping territory:

• Explore with AI to understand the system
• Verify against actual behavior
• Reflect on whether the explanation makes sense
• Critique whether you have the full picture
• Intuit what feels off or incomplete

When designing:

• Explore different architectural options
• Verify each option against your requirements
• Reflect on tradeoffs
• Critique whether each option actually solves the problem
• Intuit which approach fits your context

And so on, through every phase.

The Responsibility Line

Here’s where responsibility lives:

AI’s Role	Your Role
Accelerate	Decide
Generate	Verify
Suggest	Judge
Implement	Own

AI accelerates, you decide. AI generates, you verify. AI suggests, you judge.

You own what ships.

When to Adapt This

This framework came from a specific context: migrating legacy code in an unfamiliar language with high stakes.

Different contexts might need adaptation:

• Greenfield projects: Less “map territory,” more “design target”
• Low-stakes code: Lighter verification
• Familiar territory: Trust intuition more, explore less

But the core holds: use AI as a force multiplier for your judgment, not a replacement for it.

The Hard Part

I know this framework. I built it from my own experience.

And I still struggle to follow it sometimes.

Because we’re human. Generation is exciting, verification is boring. Shipping feels productive, being careful feels slow.

The next post is about that — why this is hard, and what to do about it.

---

Previous: How I Migrated a Payment System with AI

Next: Why AI Makes Us Lazy (And How to Fight It)