It started as a philosophical exercise.

A friend and I were debating how to test AI-generated code, and we ended up building a five-layer framework for thinking about what AI can and cannot replace. You can read that chain in my previous post.

But as we were mapping out the layers, something practical emerged: the framework maps directly onto market dynamics. Which industries are turning red, which are still blue, and crucially — where you should position yourself.

This post is that map.

The Five-Layer Map of AI Risk

Here are the layers, ranked from most-AI-replaceable to least:

Layer 4    Meta-Cognitive Generation       → DEEPEST BLUE OCEAN
            Creating new frameworks where none exist

Layer 3    Meta-Domain Knowledge            → BLUE (thinning)
            Knowing what a good question looks like
            Designing verification loops

Layer 2    Software Engineering Craft       → PURPLE (competitive)
            System design, architecture, maintenance
            "Can write code but can't maintain systems"

Layer 1    Application Domain Knowledge     → BLOOD RED (commoditizing fast)
            Syntax, API usage, framework conventions
            "What LLMs are eating right now"

─────────────────── Embodied Divide ───────────────────

Layer 0b   Instrumental Embodiment          → BLUE (tech immature)
            Robots with sensors and actuators
            Physical interaction feedback

Layer 0a   Native Embodiment                → DEEPEST BLUE (structurally irreplaceable)
            Time-integrated life experience
            Subconscious compression of lived failures
            Social embeddedness over decades
            Mortality as a cognitive structure

Each layer bleeds into the layer below it, but the speed of bleeding slows dramatically. Layer 1 is already commoditized. Layer 4 may never be.

Three Strategic Principles Derived from This Map

Principle 1: AI Penetration Speed = Margin Collapse Speed

The density of "AI can finally do X" news in a domain is inversely proportional to the profit margin remaining in that domain.

Every time you hear "AI can finally do X," X just became a red ocean. Not because AI does it perfectly — but because the barrier to entry dropped to zero, supply exploded, and prices collapsed.

The corollary is more interesting: the moment a layer commoditizes, the layer above it gains premium. When code generation goes to zero marginal cost, knowing what code to generate — the judgment of which feature matters, which abstraction holds — becomes the scarce skill. AI commoditizes the bottom and pays the top.

Principle 2: The Stronger AI Gets, the Higher Human Premiums Get

This is the upside of Principle 1.

When Layer 1 (application knowledge) commoditizes:

• Before: "I know Python and React" → valuable
• After: "I know Python and React" → table stakes
• Premium shifts to: "I can tell you which parts of your system will rot in 6 months" (Layer 2)
• Or: "I can design a verification loop that catches what your AI misses" (Layer 3)

AI makes the pie. But dividing the pie — knowing who gets what slice, when, and why — is a craft that making the pie doesn't teach you.

This explains a pattern I've observed: the most successful teams I know don't hire for "AI skills." They hire for judgment in the layer above where AI currently operates. When AI was writing individual functions (2023-2024), the premium went to architects. When AI started generating entire features (2025), the premium went to those who could design verification systems for those features.

Principle 3: Stand Perpendicular to AI's Penetration Direction

Most career advice says: "Learn AI tools, become an AI expert, ride the wave."

This framework suggests the opposite.

The highest-leverage position is orthogonal to AI's current penetration direction:

• AI is penetrating Layer 1 (application knowledge) → You stand in Layer 2 building verification systems
• AI is penetrating Layer 2 (writing code) → You stand in Layer 3 designing judgment criteria
• AI is approaching Layer 3 (meta-knowledge patterns) → You stand in Layer 4 creating new frameworks
• AI gains a body (Layer 0b) → You stand in Layer 0a doing time-integrated, irreducibly lived work

Never compete on the layer AI is currently eating. Compete on the layer above it.

This isn't about being "better than AI." It's about occupying a different dimension of the problem space. AI generates outputs; you validate them. AI optimizes within a framework; you question whether the framework is right. AI processes information; you integrate experience across time.

Map Yourself Against the Framework

Take whatever you're investing in — career, company, side project — and plot it:

The most dangerous position: only operating in Layer 1. Knowing how to write prompts, knowing API syntax, knowing the "best practices of 2026" — these have a half-life measured in months.

The safest position: operating across multiple layers, where each layer's output feeds judgment in the layer above:

• Writing code (Layer 2) → Designing testing frameworks (Layer 3) → Creating the philosophy of why testing matters (Layer 4) → Grounding it in real shipped products that have failed and recovered (Layer 0a)

This chain is self-reinforcing. No two links are parallel to AI's trajectory.

What This Means in Practice

Three concrete takes:

1. If you're early in your career (~20s) — Spend less time chasing "AI skills" and more time accumulating time-integrated experience in a real domain. The 20-year lawyer whose judgment you trust? That trust comes from watching 2,000 cases play out, not from reading 2,000 case summaries. Start building your 2,000 cases now. The domain matters less than the depth.

2. If you're mid-career (~30s-40s) — You have enough Layer 0a time-integration to be dangerous. Double down on the intersection: your specific industry knowledge (Layer 1) × your engineering/management craft (Layer 2) × your ability to design how work gets done (Layer 3). The intersects are where AI has the hardest time following.

3. If you're building products — Design your business so it occupies at least two layers, and the relationship between them is vertical. A tool that writes code (Layer 1-2) is a feature. A tool that writes code and validates it against your specific business rules (Layer 2-3) is a product. A tool that writes code, validates it, and teaches you how to get better at both (Layer 2-3-4) is a platform.

The Closing Principle

The framework we built wasn't meant to be a career guide. It was meant to answer "why is testing AI code so hard?" But the answer revealed something bigger.

The single organizing principle:

Stand perpendicular to AI's penetration direction. Never compete on the layer AI is currently eating.

AI eats layers from bottom to top: Layer 1 first, then Layer 2, then approaching Layer 3. Each time it moves up, the premium shifts to the layer above. The people who see this in time — who pivot from "learning AI tools" to "designing what AI tools cannot design" — will be the ones who don't just survive the reddening oceans, but own the islands that remain.

The islands are the layers AI cannot reach because they're not made of information. They're made of lived time.

This is the second in a series. The first traced the philosophical chain from "how to test AI code" to "what makes us human." The framework developed in that post — the five layers of knowledge and the incompressibility of lived time — is what this strategic map is built on.

Follow if you want the next thread: what "verification systems as learning systems" looks like in practice, and how the ai-qc package we built operationalizes this framework.