The 3 Stages of Becoming AI-Native: Grunt, Architect, and the One Who Designs Architects

Nobody becomes AI-native overnight. Watching teammates who had never opened Claude Code grow into AI-native builders, we noticed something: regardless of role — backend, frontend, PM, designer — they all climb the same three steps. Here's the roadmap we keep seeing, told through one metaphor: building a house, and you're the person in charge of windows.

The "window" is just a stand-in. Swap it for a form, a Figma component, or a backend model and the story holds.

Stage 1 — The Grunt: doing the same work, just faster

At this stage, the teammate fixes problems one at a time as they appear. In house terms, the day looks like this:

• Spot a crack in the living-room window, fix that window
• The living-room window is too small — revisit the design
• The bathroom only needs a small vent window, but the plan has a full-height pane — correct it
• The entry needs a full pane but has a small window — swap it
• Add a sliding mechanism to the bedroom window
• Notice the windows ignore heating, and rework them again

It's running room to room, patching whatever's visible with AI. Speed genuinely improves — but if your old pace was 100, this is maybe 150. Better, yet the way you work hasn't changed.

Still, the grunt stage matters, because the tedious repetition is the prerequisite for what comes next. Use AI this way long enough and, if you're going to become AI-native, you eventually ask:

"I feel like I'm using this wrong — isn't there a better way?"

That question is the fork in the road.

Stage 2 — The Architect: stop doing the work, design how the work gets done

Before running room to room, the architect writes a file first — call it window.md. It spells out what a window is, what it's for, and the conditions for a good window:

• A bathroom window is for ventilation, so it should be angled or small enough that no one can see in.
• A living-room window: bigger is better for openness — but account for winter heating.
• When you design a living-room window, design the opposite window too, for cross-ventilation.
• …and so on, window types A, B, C.

Then they spin up agents against that spec: a window-building agent, an install agent, a repair agent, a maintenance agent — each consulting window.md to do its job. This person no longer installs or repairs windows. They edit window.md and the window agents.

Here's the crux: all those bruises from the grunt stage taught them exactly what AI is good and bad at — so they can now re-architect their recurring work as AI workflows. And note this: you cannot jump straight to the architect stage. Without having built and broken windows with AI countless times, you simply can't tell what's possible and what isn't.

If you want an AI-native organization, the real lever is how many architect-stage people you grow inside the team.

Stage 3 — The Self-Improving Architect: designing the architect itself

From here it gets rare, and frankly radical. I went back and forth on whether to include it, but here's one more idea. In a line, this stage is: you design the architect.

This person no longer hand-writes window.md or window_fix_agent.md. Instead they design a system that improves those things on its own — for now, call it the Self-Improving window agent.

Here's what it does. Given a task — "we need to build this house" — it handles the design, building, installation, and maintenance of every window itself, in place of a human. But the important part: after every job, it's scored — by a human or by another AI. Each new house's windows earn a score, and each time it forms a new hypothesis to push that score higher:

"The windows on this house got this feedback. To raise the score, what if I add a dedicated maintenance agent?"

Run that loop across hundreds or thousands of houses and the agent gets steadily smarter. The person at this stage doesn't build window.md or window agents. They design the system that produces them.

Why is this so hard inside a normal company? Leadership struggles to even grasp the concept, and it rewrites how the company fundamentally operates — which is nearly impossible for an individual contributor to drive top-down. Outside a small team of high-leverage people, it's vanishingly rare.

The takeaway — you can't skip a stage

The path to AI-native comes down to this:

1. Grunt — do existing work faster with AI (the unavoidable rite of passage)
2. Architect — re-architect how you work as *.md specs + agents
3. Self-Improving Architect — design the system that produces the architects

The most important point: you can't skip a stage. The trial-and-error of grunt work becomes the intuition for architecture; the experience of architecture becomes the instinct for designing architects. So if you want to build an AI-native organization, the first move isn't adopting a tool — it's giving your people the time to climb these steps.

---

Potential (포텐셜) is the expansion partner for Korean and Asian founders going West — we design and build products the AI-native way. If you're figuring out how to grow an AI-native team, book a consultation.