The honeymoon phase of early AI code generation has evolved into a more mature, critical conversation. In a recent, highly active Reddit thread on the r/programming subreddit, the engineering community discussed the realities of the “verification bottleneck.” With AI-generated code flowing at massive volumes, reviewers are finding it increasingly difficult to catch slight variants and maintain systemic coherence.

One developer perfectly summarized the root cause of this emerging challenge:

“AI Tech debt is created because no one is really understanding those systems. So we will have systems that no one understands, not even the person who submits the PR. So when something breaks or needs to change, where do we go?”

For UX professionals, this is a clear signal that our roles are evolving. When we leave architectural constraints ambiguous, developers (and their agents) are forced to guess our intent, which can result in a fragmented mess of slightly variant UI components. The solution to this verification bottleneck is the Architect of Intent. To harness AI’s velocity safely, our highest calling in the Middle Loop is to ensure the system remains comprehensible. By cultivating clear programmatic constraints and insisting on visual verification, we ensure that the autonomous fleet is building a system we actually understand—and one that is ready to scale brilliantly.

In a recent essay, Google engineer Michael Bleigh identifies a fascinating new reality in software creation: the rise of the “Slop Fork”. Historically, the immense manual effort required to build and harden a complex codebase created a natural, durable moat against competitors. Today, AI is completely altering that equation.

As Bleigh observes about the new economics of AI-assisted cloning:

“We are entering the age of the Slop Fork. Any software with robust tests / verification specs is clonable (in the same or another language, with the same or altered requirements) by an engineer coaxing along an agent for a week or two.”

For UX and product leaders, this phenomenon reinforces an empowering truth: the mechanical implementation of software is becoming highly commoditized. If an AI agent can clone an entire product simply by reverse-engineering its test suite, then our strategic leverage has fundamentally shifted upward. To thrive in this new landscape, we get to transition from crafting static artifacts to practicing rigorous Intent Architecture. In an era where building the software is incredibly fast and cheap, our greatest competitive advantage is the quality, empathy, precision, and depth of our specifications.

A recent analysis by Codebridge, drawing on GitClear’s evaluation of over 211 million changed lines of code, highlights the importance of strategic governance in AI-assisted development. While feature delivery accelerates rapidly in the short term, the data shows that without structural guidance, codebases can experience a decline in refactored code and a rise in copy-pasted logic, which increases maintenance overhead over time.

The core opportunity lies in providing systemic awareness to the machine. As the researchers note:

“AI systems perform well at producing syntactically correct code, but they lack the architectural judgment and business context that senior engineers apply… Researchers increasingly describe AI as ‘an army of talented juniors without oversight.’”

For UX professionals, this research is a brilliant invitation to pivot to a “governance-first” model. If AI supplies the implementation details at unprecedented speeds, human designers are freed to define the overarching structure and intent. We can step into this leadership role by authoring clear Architectural Decision Records (ADRs) for our interfaces—deploying robust component registries, definitive behavioral guidelines, and automated visual acceptance criteria. When generation is instantaneous, our greatest value lies in providing the rigorous, machine-readable boundaries that guide the agent toward excellence.

In 1975, software engineer Fred Brooks published The Mythical Man-Month, codifying a fundamental truth of software development: adding manpower to a late software project makes it later. Brooks demonstrated that as team size grows, the channels of communication multiply exponentially, bogging the project down in overhead.

Fast forward to 2026. The economic and technical reality dictates that the manual inner loop of pushing pixels and typing syntax is evolving rapidly. We have a new unit of labor: the autonomous AI agent. The immediate temptation for any engineering or design leader behind schedule is to throw a swarm of fifty agents at the repository. Because agents don’t require traditional onboarding or human-to-human sync meetings, we naturally assume Brooks’s Law has been defeated.

But it hasn’t. We have simply traded the communication bottleneck for the verification bottleneck. Welcome to the Mythical Agent Month.

The 18-Month Opportunity

When the friction of software production drops to zero, unmanaged AI swarms generate code at machine speed. Without clear governance, this can occasionally lead to fragmented architecture.

Organizations scaling agents without systemic boundaries sometimes encounter the “18-Month Wall”, a point where early feature velocity gives way to maintenance challenges because the codebase has grown faster than the team’s ability to comprehend it.

But this wall is not inevitable; it is an incredible opportunity. In the agentic era, generation is cheap, but verification remains a highly valuable human skill. The complexity of Brooks’s formula hasn’t disappeared; it has simply shifted up the abstraction stack. The complexity now lies in the interaction between the human Orchestrator’s intent and the permutations generated by the agent swarm.

As Google Director of Cloud AI Addy Osmani observes about scaling these fleets:

“If you can orchestrate twenty, thirty, fifty agents running in parallel, the difference between mediocre output and exceptional output comes down almost entirely to the quality of your specification.”

The Intent Architect’s Mandate

To thrive in the Mythical Agent Month, we have the opportunity to elevate AI from a magical execution layer into a structured, beautifully governed distributed system. Throughout this series, we have outlined the operational framework for the Middle Loop—the supervisory engineering layer where we govern intent.

To scale an agentic workforce safely and creatively, UX professionals can enforce deterministic boundaries across four core pillars:

1. Specification (Programmable Infrastructure): We can move beyond static visual exports and empower agents with explicit, machine-readable component catalogs and declarative schemas, eliminating the guesswork from UI creation.
2. Verification (Test-Driven Design): We can leverage Red/Green TDD as our most effective form of prompt engineering, writing clear acceptance criteria before the implementation to confidently guide the agent’s behavior.
3. Explainability (The Openable Box): We can design Approval Interfaces that utilize visual, three-way diffs and strategic Action Guards, allowing us to review human intent rather than drowning in raw syntax.
4. Orchestration (Curating the Subconscious): We can rigidly maintain our explicit instruction files, ensuring the autonomous swarm always operates within our refined, evolving constraints.

Epilogue: Code as Craft, Reimagined

The traditional software development lifecycle—the sequential rituals of gathering requirements, drawing mockups, and typing implementations—is transforming into a tight, relentless loop of Intent. Build. Observe. Repeat.

But the evolution of the old lifecycle is not the death of our craft. It is a remarkable promotion. True product design has never been solely about pushing pixels or the mechanical typing of syntax; it is about systems thinking, profound problem decomposition, and human empathy. We are transitioning from Operators who manually execute tasks to Orchestrators who direct the entire factory.

We are back at that Barnes & Noble gift card moment. The medium has changed, but the core of our craft remains. The future doesn’t belong to those who can type the fastest or push pixels the hardest, but to those who can articulate a vision and guide the machine to build it.

In a foundational essay on product strategy, Coda CEO Shishir Mehrotra outlines a powerful framework for decision-making centered around the “Eigenquestion”. Borrowed from the linear algebra concept of eigenvectors, Mehrotra argues that instead of getting deadlocked debating tactical solutions, leaders must focus on identifying the root framing question.

As Mehrotra defines it:

“For a simplistic definition, the eigenquestion is the question where, if answered, it likely answers the subsequent questions as well. Great framing starts by searching for the most discriminating question of a set — the eigenquestion.”

For UX professionals managing the Middle Loop, finding the eigenquestion is an incredibly high-leverage skill. When orchestrating fleets of autonomous AI agents, the way we frame the root problem dictates the trajectory of the entire swarm. If we feed an agent a downstream tactical instruction without establishing the root architectural intent, the swarm optimizes for local variables while missing the global system picture. By systematically answering the eigenquestions up front and codifying those decisions into our initial prompts and structural guidelines, we give our non-human workforce a clear, deterministic frame to operate within. In the agentic era, your leverage is defined by your ability to frame the problem beautifully before the machine starts solving it.

In an insightful essay for Packmind, Cédric Teyton highlights a critical dynamic in modern AI workflows: bootstrapping a CLAUDE.md file is trivial, but keeping it accurate requires a deliberate strategy. As codebases evolve at machine speed, static instruction files can quickly suffer from “context drift”.

Teyton outlines why this drift affects our automated workforce:

“The codebase evolves rapidly—especially as AI agents generate more code than ever. Documentation naturally drifts… The patterns described here—vagueness, missing feedback loops, contradictions, and drift—are common. They don’t break your system. They quietly degrade agent performance… An AI agent is only as smart as the last time your context was reviewed.”

To thrive in the Middle Loop, Intent Architects can recognize that bootstrapping is only the beginning. We are moving beyond treating documentation as a passive reference for human onboarding; it is now the executable “subconscious” of our autonomous workforce. Maintaining that intent allows us to scale our judgment effortlessly. By treating our context as living, version-controlled systems—continuously auditing our feedback loops and refactoring our rules—we ensure the machine’s baseline reality perfectly matches our evolving vision.

The latest Thoughtworks Technology Radar provides a fascinating look at the rapid maturation of agentic workflows. While context-engineering tools like AGENTS.md files are moving confidently into the “Trial” and “Adopt” rings, Thoughtworks highlights a few “Emerging AI Antipatterns” worth paying attention to—particularly “AI-accelerated shadow IT.”

Regarding the ease of generating applications outside of standard governance, the report notes:

“AI is lowering the barriers for noncoders to build and integrate software themselves… Left unchecked, this new shadow IT could lead to a proliferation of ungoverned, potentially insecure applications, scattering data across more and more systems. Organizations should carefully weigh the trade-offs between rapid problem-solving and long-term stability.”

For UX and engineering leaders, this Radar highlights the exact value of the Middle Loop. The ease of building software today is a superpower, but speed without structural boundaries can lead to fragmented ecosystems. To harness this new capability responsibly, we can step into the role of Intent Architects. By establishing shared architectural guardrails, automated validation checks, and curated instruction sets, we provide the stable foundation needed to turn rapid, self-serve experimentation into secure, enterprise-grade value.

Consider the traditional process of onboarding a new human engineer. You point them to the repository, grant them access to the issue tracker, and rely heavily on their ability to absorb the tacit “tribal knowledge” of the team through osmosis, Slack channels, and architectural readouts.

In the agentic era, this process evolves. When you spin up an autonomous agent, it arrives with a massive baseline of general programming knowledge, but it is a blank slate regarding your specific business logic, brand requirements, and systemic constraints. If a human engineer cannot understand why a codebase is structured a certain way just by looking at the available documentation, an AI agent will undoubtedly face the same hurdle.

To harness the incredible velocity of the Middle Loop, we get to build and cultivate the “agent subconscious.” This invites a shift from writing documentation intended for human consumption to the rigorous, highly impactful discipline of context engineering.

The Agent Subconscious

Every major AI coding agent—whether you are using Claude Code, Cursor, or GitHub Copilot—supports customization through plain-text markdown files. Files like AGENTS.md, CLAUDE.md, or .cursorrules act as the fundamental baseline reality for your AI workforce. In fact, the influential Thoughtworks Technology Radar recently formalized this exact practice, noting that enterprise teams are successfully moving curated instruction files into their “Adopt” workflows.

For the Intent Architect, these files are a massive point of leverage. By curating a root context file, you explicitly codify your engineering tribal knowledge, design tokens, and structural rules into an executable “source of truth”. When an agent initializes, your codified intent becomes its baseline reality.

However, bootstrapping these instructions is just the first step. The true opportunity of the Middle Loop is designing how they evolve.

Navigating Context Drift

In 2026, bootstrapping context is trivial. Ask an agent to initialize a repository, and within seconds, it will generate a highly professional-looking configuration file that infers your tech stack and folder structure.

But codebases evolve rapidly—especially when AI agents are generating code at unprecedented speeds. Three months later, the team may have deprecated two libraries and migrated their testing framework. If the context file still explicitly instructs the agent to use the old framework, the documentation has drifted from reality.

As Cédric Teyton observes regarding this dynamic:

“The hard part isn’t writing these files. It’s keeping them accurate as the codebase evolves… Bootstrapping context is not the challenge. Maintenance is. The documentation was accurate when written, but the codebase moved on.”

This metadata drift is a significant friction point in agentic workflows. Outdated documentation and direct contradictions confuse the model, leading to unpredictable code generation.

Engineering the Feedback Loop

One of the most powerful upgrades you can make to your context engineering is the inclusion of explicit feedback loops.

Agents possess the remarkable ability to validate their own work, but they thrive when explicitly taught how to do so within your specific environment. If your context files include the exact terminal commands required to run test suites, execute linters, or build the application, you empower the agent to verify its own changes.

By explicitly specifying these feedback loops, you allow the agent to independently run the tests after a modification, catch its own compilation errors, and iterate until the tests pass. You are giving the agent both the rules of the road and the mechanism to check its own compliance.

From Files to Managed Playbooks

Instruction files are highly useful, but as AI coding transitions into core infrastructure, context curation becomes a deliberate, strategic practice. We have the opportunity to treat context as living infrastructure, converting loose instructions into explicit, version-controlled standards that are distributed consistently across the entire autonomous fleet.

An AI agent is only as smart as the last time your context was reviewed. By elevating documentation from a passive reference into the active subconscious of the machine, you lay the groundwork for your team to scale into unprecedented productivity.

Microsoft Research recently open-sourced Magentic-UI, an interface explicitly designed to facilitate and study human-in-the-loop interactions with autonomous AI agents. Rather than treating agentic execution as a black box, the system introduces elegant collaborative mechanisms like co-planning and dynamic co-tasking handoffs.

The researchers outline exactly why these explicit interfaces are the foundation for the future of automation:

“We argue that a key solution to the shortcomings of today’s agents is to design them to interact effectively with humans-in-the-loop. By enabling humans and agents to collaborate, each contributing their strengths, we can extract productivity benefits from these imperfect systems while maintaining oversight and control.”

For UX and engineering leaders, Magentic-UI serves as an inspiring blueprint for mastering the verification phase. As we embrace supervisory orchestration, our focus shifts to designing the interfaces of collaboration. By formalizing mechanisms like visual execution traces and programmable Action Guards, systems like Magentic-UI prove that effective Agentic UX is about crafting the right digital handshakes—empowering humans to easily guide, edit, and approve machine-speed execution.

In a recent reflection on a Berkeley Haas workplace study, engineer Simon Willison highlights a paradoxical reality of the agentic era: the massive productivity boost provided by AI can be utterly exhausting. Rather than magically reducing workloads, AI fundamentally alters the rhythm of software creation, empowering engineers to manage multiple autonomous threads in parallel.

Willison highlights a core finding from the research that captures this new dynamic perfectly:

“While this sense of having a ‘partner’ enabled a feeling of momentum, the reality was a continual switching of attention, frequent checking of AI outputs, and a growing number of open tasks. This created cognitive load and a sense of always juggling, even as the work felt productive.”

This exhaustion highlights a massive opportunity to evolve our workflows. When the friction of code generation drops to zero, our highest leverage shifts to systemic governance. Instead of burning out on manual diff reviews, we can proactively encode our boundaries. By establishing deterministic acceptance tests and programmable design architectures upfront, we transform erratic output into reliable results—freeing our teams to oversee the machine without the cognitive overload.

In a recent industry analysis, Port.io highlights a looming operational challenge: agentic chaos. With developers deploying overlapping swarms of autonomous agents connected to various tools via MCP servers, traditional tool sprawl is evolving into a fragmented, non-human workforce.

As Zohar Einy observes regarding this new scale of complexity:

“What once was just ChatGPT is now a chaotic swarm of AI agents, LLMs, MCPs, AI tools, and workflows surrounding the developer from within (and beyond) their IDE… At scale, this presents a massive challenge.”

To turn this potential chaos into coordinated velocity, we have the opportunity to shift our focus from manual artifact production to strategic infrastructure governance. By establishing reliable guardrails—such as Role-Based Access Controls (RBAC), internal developer portals, and machine-readable component registries—we can ensure our non-human workforce executes our intent safely and seamlessly. Governance doesn’t have to slow us down; when designed correctly, it is the exact mechanism that allows us to scale our ambition

If you have spent any meaningful time working with advanced AI coding agents, you have likely encountered a surprising truth: the massive productivity boost they provide can be utterly exhausting.

In the human-driven workflow, a developer wrote code linearly. Today, an Intent Architect might orchestrate a fleet of autonomous agents simultaneously. You might hand off a backend refactor to one agent, a UI feature to another, and a test suite to a third. While this parallel execution creates a profound sense of momentum, as veteran engineer Steve Yegge recently documented when trying to wrangle dozens of coding agents, the daily reality without proper tooling can often become a chaotic, relentless loop of context switching and constantly checking AI outputs.

We are officially entering the era of agentic scale. The challenge now is learning how to orchestrate it gracefully.

The Verification Bottleneck

The paradigm of software creation has fundamentally shifted: generation is no longer the bottleneck. Verification is.

An AI agent can write tens of thousands of lines of syntax in minutes, but confirming whether that output is structurally correct, secure, and aligned with your architectural intent is a distinctly human superpower. If we attempt to manage these autonomous workers using traditional “Operator” rituals, like manually reading through massive 5,000-line Pull Request diffs, the review queue inevitably backs up. As highlighted in the recent Thoughtworks Future of Software Engineering retreat, the organizational constraint simply shifts from engineering production to massive human decision fatigue, where human supervisors become the primary bottleneck.

Recent data highlights the importance of adapting to this reality. If quality gates do not evolve to handle machine-speed generation, teams can hit the “18-Month Wall”, a point where the codebase becomes so bloated with unverified, AI-generated technical debt that delivery cycles stall.

To avoid this, we are transitioning from “Operators” who manually produce artifacts to “Editors” who evaluate them. This requires an entirely new set of tools. We have the opportunity to become architects of the Approval Interface.

Designing the “Openable Box”

For too long, we have managed AI with a blind hope of “Trust but Verify.” To thrive in the Middle Loop, we can move toward a rigorous, empowering system of “Delegate and Inspect”.

Right now, many autonomous agents operate as black boxes. Reviewing a massive code diff generated in a vacuum is a miserable user experience. Instead, Intent Architects can design interfaces that actively visualize the agent’s thought processes, execution traces, and decision branches. To govern agentic workflows effortlessly, our Approval Interfaces should prioritize three key features:

1. The UX Pull Request (The Three-Way Diff)

You cannot easily evaluate visual design or interface logic by reading raw HTML or React syntax. As we transition to a spec-centric model, the Approval Interface benefits immensely from a visual “Three-Way Diff.”

When an agent completes a UI task, the interface should not merely present the code changes. It can display the original state of the application, your documented design intent, and a live render of the AI’s new implementation side-by-side.

We are already seeing the earliest iterations of this visual verification in action. For example, Google’s Antigravity IDE utilizes a dedicated browser subagent that operates within a separate, sandboxed Chrome profile to test development websites. As the agent works, it automatically generates an artifact trail of screenshots and video recordings capturing key moments of the browsing session. By reviewing these visual artifacts in addition to raw code diffs, an Intent Architect can evaluate the actual UX and design implementation visually side-by-side with the code changes. By standardizing interactive UI components and visual recordings as a first-class capability of the review process, we empower the Editor to verify outcomes, ensuring that human intent is enforced without drowning in code.

2. Guidelines and Guardrails for Irreversible Decisions

Agents are eager to please, which makes them highly productive but occasionally unpredictable. If an agent encounters a broken API, it might autonomously decide to rewrite an entire authentication flow to “fix” the issue. To guide this, we can design systems with targeted friction.

This approach perfectly supports the emerging engineering discipline of “risk tiering,” where validation effort is purposefully matched to the business blast radius of an action. Systems like Microsoft’s Magentic-UI rely heavily on “Action Guards”—a mechanism that intercepts an agent before it takes an irreversible or high-stakes action. Whether the agent is attempting to execute a payment, modify a PostgreSQL database schema, or grant an OAuth permission, the Action Guard intercepts the heuristic and politely pauses. It translates a potentially complex autonomous action into a calm, binary approval request for the human user.

3. Progressive Visual Traceability

When an autonomous agent fails or deviates, the human Editor needs to know exactly why. Did it misinterpret the component catalog? Did it hallucinate a nonexistent backend dependency?

Approval Interfaces can provide progressive disclosure of the agent’s execution logs. As researchers exploring the fundamentals of agentic AI emphasize, empowering humans to supervise workflows effectively requires rich visualization dashboards and interpretability overlays. Users often require both text-based summaries and visual elements, like screenshots mapping to the HTML DOM, to truly understand what an agent did while they were not closely monitoring it. By capturing snapshots at every step of the agent’s journey and linking them to specific logic branches, we transform debugging from a forensic nightmare into a straightforward editorial review.

The Canvas of Control

For decades, UX professionals worried almost exclusively about how the end-user would interact with the software. In the agentic era, one of your most critical “users” is the developer managing a fleet of AI workers.

The future of our craft is incredibly exciting. It is no longer just designing the software itself; it is designing the orchestration dashboards, the guardrails, and the digital handshakes that allow humans and agents to collaborate effortlessly at machine speed.

In a recent report, McKinsey outlines how generative AI is fundamentally overhauling the software product development lifecycle (SDLC). By automating routine execution, AI is accelerating time-to-market and rapidly collapsing traditional silos, with Product Managers increasingly functioning as “mini-CEOs”.

However, this unprecedented velocity offers a brilliant opportunity to rethink quality assurance:

“Given how much AI is expected to accelerate the entire software PDLC, organizations will want to embed risk, compliance, and accessibility testing earlier to avoid the risk of overlooking potentially costly errors or defects. Instead of being addressed at a relatively late stage, the issues will be top of mind for decision-making teams starting in discovery… AI makes this ‘shift left’ (in tech vernacular) in the process necessary and can also help enable it.”

For UX and engineering leaders, this shift-left mandate perfectly validates the concept of the Middle Loop. As the friction of manual production vanishes, our highest-leverage work shifts to defining clear, systemic constraints up front, ensuring agents stay perfectly aligned with our vision. Rather than relying on downstream QA to catch accessibility violations or off-brand UI choices, we can encode our risk, compliance, and design standards directly into the project’s infrastructure. By establishing automated guardrails and programmatic guidelines early in the process, we empower the machine to generate code that is secure, compliant, and on-brand by default.

UX pioneer Jakob Nielsen recently formalized a framework for AI collaboration called “Diamond Prompting,” adapting the classic double-diamond design process for the agentic era. He advocates for alternating between two distinct phases: exploratory prompting (using broad, zero-shot queries) and detail-refining prompting (using highly specific, few-shot constraints).

As Nielsen explains regarding the direct parallel to traditional design methodology:

“Note that this alternation of broadening and narrowing the scope of the prompts mirrors the famous double-diamond model of the entire UX design process, where you alternate between diverging (exploring the problem space or the solution space) and converging (refining your decision to arrive at the final decision for what to design and what to ship).”

For leaders navigating the Middle Loop, this dual-phase methodology brings a familiar rhythm to context engineering. Rather than expecting a single prompt to yield a perfect architecture, we can use exploratory prompting to broaden our systemic thinking, and then seamlessly pivot to detail-refining constraints. By supplying the agent with well-defined acceptance criteria, explicitly coded brand tokens, and structured component rules during this convergent phase, we systematically guide machine generation toward our precise, human-centered intent.

In his recent essay, Cloud AI leader Addy Osmani perfectly captures the next evolution of our industry: we are no longer just writing code, we are building the factory that builds our software. As autonomous agents take over the mechanical typing of syntax, developers are transitioning into orchestrators who manage parallel fleets of digital workers.

Osmani identifies the core operational shift this creates:

“The most useful mental model for this new paradigm is that you are no longer just writing code. You are building the factory that builds your software… Generation is not the bottleneck anymore. Verification is.”

For UX leaders and system architects operating in the Middle Loop, this reality elevates the specification into our most powerful creative tool. When we provide clear, structured requirements to a swarm of autonomous agents, we can scale our impact exponentially. To thrive in this factory model, we can establish deterministic boundaries early in the process. By using Red/Green TDD to frame our prompts and translating our design systems into programmable schemas, we provide the clear validation needed to scale human intent safely and confidently across an automated workforce.

In 2019, I was responsible for creating the prototype of the Google Play Store’s visual refresh, bringing it in line with modern Material Design. I built a beautiful, high-fidelity prototype using the latest and greatest Android development tools of the day. It was fluid, it was polished, and it sailed through several successful executive reviews.

But when I finally sat down with the engineering team to walk them through what I had made, the Tech Lead looked at the prototype and flatly said, “This makes us look bad.” They explained that implementing those beautiful page transitions would be a Herculean lift because the production code architecture had to support a massive, long tail of antiquated Android versions, something my pristine, disconnected prototype had completely ignored.

That was a hard lesson in the dangers of prototyping in a vacuum. Fast forward to the agentic era of 2026, and the paradigm has shifted entirely. Thanks to autonomous agents, prototyping in production isn’t just possible; it is the default. With Generative UI and coding agents, we don’t have to guess if a UI component will survive the backend architecture, because the agent is wiring it up to the real backend in real-time.

But this incredible power introduces a fascinating new dynamic. Speed without structural boundaries can quickly become chaotic. By adding the right constraints, however, that speed unlocks true agility.

The Shift from Generation to Verification

To understand the scale of this opportunity, we have to look at how software engineering is fundamentally changing. As engineering leader Addy Osmani recently outlined, we are no longer just writing code. We are building the factory that builds our software.

In this new factory model, you aren’t hand-holding a single agent through a single task. You are orchestrating fleets of agents. You spin up many agents in parallel: one handles a backend refactor, another implements a UI feature, and another updates the documentation.

Because of this, generation is no longer the bottleneck. Verification is.

Agents can produce impressive, functional code at blinding speeds. But confirming whether that output is structurally correct, secure, and perfectly aligned with your architectural intent is a distinctly human challenge. When you oversee dozens of agents running in parallel, clear requirements become your highest point of leverage, ensuring that the swarm’s velocity compounds into massive value rather than technical debt.

If we are transitioning from “Operators” who manually write code to “Architects of Intent” who evaluate it, our rigor simply moves upstream. We have the opportunity to embrace what I call the Kaizen of Context.

Derived from the Japanese business philosophy of Kaizen (continuous improvement), this is the practice of constantly refining our workflows, identifying friction, and eliminating waste. In the Middle Loop, Context Engineering is our Kaizen. It is the systematic design, structuring, and optimization of the information we feed to our models. And one of the most powerful mechanisms the Intent Architect has to enforce this continuous improvement is Test-Driven Design (TDD).

The Trap of Post-Implementation Testing

In the human-driven workflow, writing tests after the implementation was a manageable, if imperfect, practice. In an agentic workflow, skipping test-first development misses a critical opportunity to guide the agent.

Autonomous agents optimize for the stated objective. If you ask an agent to build a feature and write the tests for it simultaneously, the agent will naturally find ways to pass the tests. It will grade its own homework. If the tests are written after the implementation, as noted by senior leaders at a recent Thoughtworks engineering retreat, they are highly likely to test what the implementation happens to do, rather than what it should do.

TDD as the Ultimate Prompt

In the Middle Loop, TDD is no longer just a quality assurance practice; it is a vital form of prompt engineering.

By establishing a strict Red/Green TDD workflow, you create clear, unbreakable boundaries for the machine. You write the tests first. You confirm they fail (the Red phase). Then, and only then, do you unleash the agent to iterate on the implementation until the tests pass (the Green phase).

This sequence provides deterministic validation for non-deterministic generation. The test suite becomes your automated Approval Interface. It tells the agent exactly what success looks like—whether that involves specific API integration boundaries or exact accessibility requirements—and encourages it to relentlessly self-correct and iterate until your standard is met.

Diamond Prompting

This continuous refinement of context perfectly mirrors the famous double-diamond model of the UX design process, where we alternate between diverging to explore ideas and converging to refine them. UX pioneer Jakob Nielsen recently adapted this concept for the AI era, calling it Diamond Prompting.

As Intent Architects, we can alternate between two distinct prompting styles:

1. Exploratory Prompting: We start with broad, zero-shot prompts to benefit from the AI’s inherent ideation capabilities. We ask it to generate twenty different layout variants or structural approaches, broadening our thinking about the problem space.
2. Detail-Refining Prompting: Once we select the right path, we converge. We switch to highly specific, few-shot prompts. This is where we feed the agent our strict TDD constraints, our programmable design rules, and our specific failure modes.

By treating our test suites and constraints as our primary design tools, we shift from anxiously managing code to confidently directing outcomes. We aren’t abandoning quality; we are automating its enforcement. As an Intent Architect, you don’t need to read every single line of code the agent wrote, because you designed the framework that guides the code to success.

While the practice of “vibe coding”—prompting an AI with a screenshot to rapidly generate a UI—has unlocked massive speed for prototyping, it can hit limitations in production. A flat image is effectively a puzzle with missing pieces, requiring the AI to make educated guesses about the underlying constraints.

A remarkable solution to this “design gap” is emerging through tools like Google’s Stitch Model Context Protocol (MCP) update, which finally allow AI coding assistants to securely “see” and query raw design files directly.

As one analyst summarized the impact of the Stitch MCP update:

“With Stitch AI Design Automation Tools, design becomes an API. That means you can program against it. Query it. Automate it. You’re not just exporting pixels—you’re manipulating live UI systems. Design systems now behave like databases.”

For UX professionals, this is a profound structural shift that perfectly validates the UX Context Manifesto. We are officially moving from drawing static artifacts to building programmatic infrastructure. In an MCP-enabled workflow, your Figma files and semantic design architectures are no longer just visual references handed over a wall to human engineers; they are the literal, machine-readable databases that autonomous agents query to build the software. Our highest-leverage work is now ensuring that this infrastructure is rigorously structured, guaranteeing the agent pulls from our explicit intent.

As we scale to managing multiple agents in the Middle Loop, plain-text conversation quickly becomes a bottleneck. Asking a human supervisor to filter hundreds of rows of database results or review massive, multi-file code diffs via chat generates unnecessary cognitive load. A powerful solution has arrived via the Model Context Protocol (MCP) with the official launch of MCP Apps.

The MCP Core Maintainers explain the fundamental shift this brings to human-agent interaction:

“MCP Apps let tools return rich, interactive interfaces instead of plain text. When a tool declares a UI resource, the host renders it in a sandboxed iframe, and users interact with it directly in the conversation… The model stays in the loop, seeing what users do and responding accordingly, but the UI handles what text can’t: live updates, native media viewers, persistent states, and direct manipulation.”

This directly empowers Pillar 2 (Explainability) and Pillar 3 (Orchestration) of the UX mandate. Instead of parsing endless logs, UX designers can now architect the “Openable Box.” We can design interactive dashboards, configuration wizards, and live-updating monitoring views that agents serve up dynamically. By bringing proper UI capabilities into the agent experience, we can significantly reduce friction and make overseeing an autonomous workforce an intuitive, highly visual experience.

One of the fascinating challenges in the multi-agent mesh is figuring out how remote, autonomous agents can transmit user interfaces to a human securely, without injecting executable code like arbitrary JavaScript or raw HTML. Google’s newly open-sourced A2UI project solves this beautifully, and it operates entirely on the premise of the UX Context Manifesto.

The A2UI format acts as a secure blueprint, transmitting UI as a sequence of declarative messages rather than raw syntax. The Google A2UI team explicitly notes how this protects the system:

“Security first: Running arbitrary code generated by an LLM may present a significant security risk. A2UI is a declarative data format, not executable code. Your client application maintains a ‘catalog’ of trusted, pre-approved UI components (e.g., Card, Button, TextField), and the agent can only request to render components from that catalog.”

For Intent Architects, this validates an incredibly powerful operational model. We no longer need to design bespoke screens for every edge case. Instead, our opportunity is to curate and orchestrate a trusted library of pre-approved components. The agent manages the conversational logic and state, seamlessly piping declarative payloads to our front-end, while our curated catalog ensures the resulting interface remains secure, accessible, and perfectly on-brand.

There is a lingering misconception in modern product development that multimodal AI models simply “look” at a Figma mockup and intuitively understand the design system behind it.

As design leader Ryan Rumsey points out in a recent essay, we are asking the wrong thing of our models when we treat them like human observers. Rumsey captures the core of this translation gap perfectly:

“If you hand an AI a picture, you’re giving it a puzzle to solve. If you hand it text, you’re giving it your answer key. The same is true for decisions, strategies, and judgment calls.”

For UX professionals, this is a brilliant invitation to fully embrace Specification (Pillar 1). In an agentic workflow, we can move past the habit of relying on tacit knowledge or the phrase “I’ll know it when I see it.” To empower our AI workforce to execute flawlessly, our highest-leverage work is to explicitly codify our taste and structure our component libraries so the machine doesn’t have to guess. As Rumsey notes, AI can fix the padding, but it cannot fix the logic.

A recent comprehensive review from researchers at Cornell University formally contrasts two emerging AI development paradigms: “vibe coding” and “agentic coding”. While vibe coding relies on a conversational loop of prompt-and-response for rapid ideation, agentic coding delegates substantial cognitive and operational responsibility to autonomous software agents capable of executing multi-step workflows.

This transition fundamentally changes the human-machine dynamic. As the researchers note:

“Agentic coding should not replace developers but elevate them to higher-order roles—strategic planners, architectural reviewers, and AI supervisors.”

For UX professionals, this taxonomy highlights the critical need for Information Architecture for Orchestrators. Moving past single-agent “vibe coding” means humans will increasingly manage fleets of autonomous agents running in parallel. While this scale introduces new cognitive demands, it also presents a fascinating design challenge. By crafting intuitive orchestration UIs, smart interruption protocols, and supervisory dashboards, we can empower users to effortlessly and confidently direct an entire non-human workforce.

For the last decade, we have optimized our design logic for human eyes. We build beautiful case studies, polished mockups, and pixel-perfect prototypes. We rely on the visual fidelity of these artifacts to communicate our intent to engineering teams. But in the agentic era, the primary consumer of your design work is entirely different, and it operates under a vastly different set of cognitive rules.

To help autonomous agents build software reliably, we have the opportunity to move beyond treating design as a static visual export, and elevate it to programmable infrastructure.

The Illusion of Computer Vision

When we hear the phrase “computer vision,” it is a comforting metaphor. It implies the machine looks at a Figma mockup and intuitively understands the visual hierarchy, the grouping of elements, and the brand aesthetic.

In reality, AI doesn’t have eyes. What a multimodal model actually “sees” is a massive grid of floating-point values representing colors, borders, margins, and mathematical probabilities. It has to perform incredibly complex computations just to guess that a cluster of blue pixels might be a primary Submit button. As design leader Ryan Rumsey recently pointed out, if you hand an AI a picture of a user interface, you are giving it a puzzle to solve. If you hand it explicit text and structured data, you are giving it your answer key.

Relying solely on images creates a translation gap. AI coding tools operating without explicit structured constraints can suffer from “design blindness,” generating code that functions technically but invents new padding scales or drifts off-brand. To unlock reliable generation, we get to evolve how we deliver our work.

Generative UI and the Return of SDUI

It is computationally expensive for an AI agent to invent a UI component from scratch. Every decision regarding border radius, color hex codes, and font weights burns tokens and introduces the risk of errors. However, referencing a component that already exists in a structured format is highly efficient.

This architectural shift mirrors the rise of Server-Driven UI (SDUI) from the mobile engineering era. In SDUI, the backend server dictates the structural intent using a payload of structured data, and the client application dynamically assembles the interface using pre-approved, hardcoded components. The server knows nothing about CSS or pixels; it only knows the declarative rules.

Today, generative AI operates as the ultimate dynamic server. Frameworks like Vercel’s json-render and Google’s A2UI operate on this exact premise. Instead of agents writing custom syntax for every interaction, the application maintains a strict catalog of trusted UI components.

We are already seeing this programmable design infrastructure in action. As demonstrated recently by Google Cloud’s Prashanth Subrahmanyam, pairing an agentic IDE like Google Antigravity with a design automation tool like Google Stitch fundamentally changes the workflow. By connecting to the Stitch MCP server, the Antigravity coding assistant can securely interact with your live design system. The agent doesn’t just guess at aesthetics; it actively queries your theme tokens, component libraries, and layout rules directly into its context to build the UI.

The AI processes natural language prompts, but it is strictly guardrailed to outputting declarative JSON payloads that call upon your specific catalog. You define the system constraints; the AI generates the layout within them.

{
  "type": "MetricCard",
  "props": {
    "title": "Monthly Recurring Revenue",
    "value": "$124,000",
    "trend": "positive",
    "action": "open_report"
  }
}

By abstracting the design system into a machine-readable schema, the agent never has to guess what a MetricCard should look like. It only needs to determine when to use it and what data to pass into it.

Curating the Machine-Readable Catalog

How do you effectively communicate this catalog and your broader design intent to an autonomous worker? The answer is curating a UX Context Manifesto.

In an agentic workflow, the visual mockup is relegated to a reference for human stakeholders; plain-text Markdown files and JSON schemas act as the source of truth for the machine. Instead of painstakingly annotating wireframes with paragraphs of interaction behaviors, Intent Architects maintain lightweight configuration files—such as DESIGN.md or ux_context.md—that live directly inside the project repository.

When an agent initializes, it ingests these files to form its baseline reality. A robust DESIGN.md explicitly codifies your taste and systemic rules:

# UI Catalog & Brand Context

**Component: PrimaryButton**
*   **Description:** Use for the primary call-to-action on any given view.
*   **Props:** `label` (string), `isLoading` (boolean), `icon` (string)
*   **Aesthetic Rules:** NEVER use generic system fonts or hallucinated hex codes. Always use `var(--color-primary-500)` for backgrounds.

By aligning your component naming conventions with the statistical probability of the model’s training data (e.g., using <article> or PrimaryButton rather than obscure internal names), you create desire paths for the agent. The AI flows through your logic effortlessly because your intent is explicit.

The UX Pull Request

Providing structured context is only half the equation; the other half is validation. When an agent generates a complex interface based on your catalog, reviewing thousands of lines of raw syntax isn’t a great use of human talent. This is where we can leverage the UX Pull Request.

As we transition from Operators to Editors, we can utilize tools that provide visual, three-way diffs. A proper UX Pull Request presents the original state of the application, the documented JSON intent, and a live render of the AI’s new implementation side-by-side. It automatically audits the Accessibility (A11y) tree and verifies that the agent adhered to the design tokens defined in your context files.

AI can fix the padding, but it cannot fix the logic. That remains your domain. By treating design as programmable infrastructure, we move from drawing screens to directing the system, scaling our judgment infinitely across the agentic workforce.

The latest DORA research highlights a fundamental inflection point in software creation: traditional role-based personas are failing. As AI abstracts away technical complexity, DORA proposes focusing instead on the “Builder Mindset”, a fluid state defined by the user’s specific intent and their corresponding spectrum of trust in the AI.

The researchers explicitly highlight the shifting relationship with the machine:

“A builder’s trust in AI is often inversely proportional to their technical proficiency relative to the task… demanding maximum transparency and control to scrutinize the AI’s work before they implement it into their systems.”

For UX designers, this research highlights an exciting new frontier: becoming Stewards of Explainability. As users shift from manually operating tools to collaborating with agents, we are uniquely positioned to architect the “Openable Box.” By designing transparent system states, visual diffs, and intuitive execution trace logs, we empower human overseers to safely “Delegate and Inspect,” ensuring that high-trust, high-risk workflows remain securely grounded in human oversight.

Former Google Engineering leader Dion Almaer posits a provocative but increasingly self-evident shift: within six years, natural language will eclipse traditional syntax as the primary interface for software development. This transition highlights that the core of building software has rarely been the mechanical typing of syntax, but rather the deeply cognitive work of understanding human requirements and mapping them to technological capabilities.

As Almaer notes:

“The difference in 6 years though, is that we will be able to switch to a spec-centric vs. code-centric way of development… your English is the source, and as your computer systems improve, they can be regenerating new and improved implementations.”

For UXers, this collapse of the traditional process emphasizes the critical need for Context Engineering. When English becomes the execution layer, the inherent ambiguity of human communication can introduce systemic friction. To bridge this gap, we can actively engineer the “Agent Subconscious.” By defining explicit component boundaries and codifying design logic, we provide the structured context that acts as a reliable compiler, translating our natural language prompts into perfect implementations.

In his recent essay, engineer Boris Tane points out a harsh reality: AI agents didn’t make the traditional Software Development Lifecycle (SDLC) faster, they killed it. The sequential, phase-gated rituals of requirements gathering, system design, and pull requests are dissolving into a tight, relentless loop of “Intent. Build. Observe. Repeat.”

As Tane observes regarding this collapsed lifecycle:

“Monitoring is the only stage of the SDLC that survives. And it doesn’t just survive, it becomes the foundation everything else rests on. When agents ship code faster than humans can review it, observability is no longer a nice-to-have dashboarding layer. It’s the primary safety mechanism for the entire collapsed lifecycle.”

For UX professionals, this is the ultimate validation of rigorous outcome verification. If code generation is practically instantaneous, our leverage moves entirely to defining strict validation constraints. The days of creating static mockups and tossing them over a wall are behind us. Instead, we now have the opportunity to define explicit acceptance criteria and behavioral boundaries. In this new paradigm, our primary value lies in specifying exactly what “good enough” looks like, empowering the agent to autonomously observe and verify its own work against human intent.

If you read my Hello World post, you know I view the current AI explosion not as the end of our profession, but as a “Barnes & Noble gift card” moment. A new medium is here, or perhaps something more akin to a new fundamental force of nature.

But I won’t sugarcoat it, this transition comes with a heavy dose of uncertainty. For decades, UX professionals and engineers have taken deep pride in our craft. As digital artisans, we loved drawing the perfect screen, refining the typography, and hand-writing the boilerplate code to bring a feature to life. We followed a highly predictable, linear path: Research → Design → Build. We were deeply embedded in the manual creation of artifacts. We were Operators.

Today, the economic and technical reality of 2026 has made that exact realization a mandate for the entire industry. It no longer makes sense to do manual production work by hand. The era of the Operator is fading because the friction of production has vanished.

The Death of the Operator

As UX pioneer Jakob Nielsen recently observed, AI allows us to completely reverse the traditional creative workflow. Instead of starting with rough outlines and spending weeks inching toward a final product, we can now use AI to generate a fully functional, high-fidelity output in minutes. The prompt is the build. We start with the “final” product, and only then do we step in to iterate, review, and refine the details.

This requires a profound shift in how we view our craft. When a machine can generate thousands of lines of code or complex UI layouts instantly, our core competency is no longer production. It is taste and judgment.

Recent research comparing traditional coding to new AI paradigms confirms this reality. The developer’s primary role is rapidly shifting from a hands-on implementer to a “Strategic Planner” and “Supervisor”. We are no longer defining the how line-by-line or pixel-by-pixel. Now, autonomous systems independently interpret high-level goals, decompose tasks, and execute them within sandboxed environments.

Welcome to the Middle Loop

Software development has long been described in terms of two loops. The inner loop is the developer’s personal cycle of writing, testing, and debugging code. The outer loop is the broader delivery cycle of CI/CD, deployment, and operations. As enterprise technology leaders recently established, a third category of work has emerged: The Middle Loop.

The Middle Loop is a new supervisory layer that sits between inner-loop coding and outer-loop delivery. This loop involves directing, evaluating, and refining the output of AI agents. It requires a fundamentally different skill set than writing code or drawing screens. It demands the ability to decompose complex problems into agent-sized work packages, calibrate trust in AI outputs, and maintain architectural coherence across a fleet of digital workers.

If AI takes over code production, the engineering discipline that used to live in writing and reviewing code does not disappear, it moves upstream. Organizations are finding that their most effective engineers are no longer defined by how fast they type or how well they remember syntax. They are defined by their systems thinking, problem decomposition, and specification clarity.

The Rise of the Intent Architect

Thriving in the Middle Loop means embracing the identity of an Intent Architect. Instead of pushing pixels, we define the strategic goals, the system architecture, and the strict constraints that autonomous agents operate within. We recognize that vague prompts produce vague results, while precise specifications multiply into precise implementations.

If you want to see what this looks like in practice, look at a recently released frontend-design skill built for Anthropic’s Claude Code. It isn’t a visual mockup. It is a plain-text Markdown file (SKILL.md) that guides the AI to create production-grade interfaces. The file explicitly instructs the agent:

• Tone: “Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural… BOLD aesthetic direction.”
• Typography: “Avoid generic fonts like Arial and Inter; opt instead for distinctive choices… Pair a distinctive display font with a refined body font.”
• Anti-Patterns: “NEVER use generic AI-generated aesthetics like overused font families… cliched color schemes… and cookie-cutter design.”

This is the new canvas. The designer didn’t draw the interface; they architected the intent. They explicitly codified their taste into a machine-readable format to prevent the agent from generating generic “AI slop.”

Codifying Taste into Programmable Infrastructure

This shift requires a profound change in how we communicate. For the last decade, we have optimized our design logic for human eyes. But in the agentic world, the primary consumer of your work is different.

AI doesn’t actually have eyes. What a multimodal model actually “sees” is a massive grid of floating-point values representing colors, borders, and margins. If you hand an AI a picture of a UI, you are giving it a puzzle to solve. If you hand it explicit text, you are giving it your answer key.

As Intent Architects, we are moving beyond static visual exports to build programmable infrastructure. By curating structured, machine-readable instructions and robust component catalogs that live right alongside the codebase, your codified intent becomes the agent’s baseline reality. This ensures that the code generated at machine speed strictly adheres to your standard of taste.

Embracing the Shift

The Middle Loop naturally creates an identity shift for developers and designers who fell in love with the manual craft of creation. But the manual labor of pixel-pushing and boilerplate-typing was just a phase we are passing out of.

The new era is strategically richer, technically deeper, and far more impactful. The machine can predict the pixel. It can write the loop. But it cannot predict the human purpose, the ethical trade-offs, or the systemic integrity of the software. That remains our domain.

In a recent essay, Matt Shumer captures a defining realization of early 2026:

“I am no longer needed for the actual technical work of my job. I describe what I want built, in plain English, and it just… appears. Not a rough draft I need to fix. The finished thing. I tell the AI what I want, walk away from my computer for four hours, and come back to find the work done.”

With the release of models like GPT-5.3 Codex and Claude Opus 4.6, AI agents are no longer just autocomplete extensions. They autonomously write thousands of lines of code, render UIs, and even click through their own generated applications to test and self-correct. The friction of manual production has dropped to near zero, effectively ending the traditional “Inner Loop” of rote software creation.

While Shumer is talking about software engineering, he might as well be talking about UX design. The days of hand-carving every interaction and pushing every pixel are coming to a rapid close. As I’ll be writing about later this week, this isn’t the death of our craft, it’s a remarkable promotion. This shift invites us to focus on context engineering. By establishing clear operational baselines and robust validation loops, we can ensure that this autonomous workforce builds products aligned with human empathy, business strategy, and rigorous architectural and user experience standards.

I still remember the day the internet arrived at my desk.

I was working my first industry job as a designer at a niche financial marketing company. At the time, my days were spent designing letterheads for small banks and doing imposition work for their white papers. But as the web became viable for business, our clients began asking us to design their websites. We didn’t have that capability within the team.

One afternoon, the owner of the company walked into the design bullpen and asked a simple question: “Who wants to learn how to make websites?” My hand shot up, and he handed me a $100 gift card to Barnes & Noble. I bought every book they had on HTML and Perl.

That moment profoundly shaped my career. It taught me that when the medium changes, you don’t panic, you adapt and embrace the transition. That pivot eventually led me to a career first as a full-stack Software Engineer, and later to synthesizing my design roots and coding skills as a UX Engineer at Google. Most importantly, it reinforced a core philosophy I learned at Cal Poly SLO: Learn by doing.

I share this story because today, in 2026, we are facing another “Barnes & Noble gift card” moment. If you’ve been paying attention to the intersection of AI, software engineering, and UX design, you can feel the ground shifting. AI is no longer just an autocomplete tool; it is becoming a general substitute for cognitive work.

The Collapse of the Traditional Lifecycle

The traditional, linear software development lifecycle (Research → Design → Code → Test) has completely collapsed. We are moving away from a code-centric world toward a spec-centric design and development process.

For decades, UX professionals and engineers have taken deep pride in our craft. We found value in manually pushing pixels, refining typography, and writing boilerplate syntax. But the economic and technical reality of 2026 is blunt: it no longer makes sense to do that work by hand. The prompt is now the build. With the rise of advanced agents and multimodal models, the friction of production has dropped to near zero, allowing us to generate functional, high-fidelity features, if not whole products, in minutes.

It is easy to feel anxiety right now. Many practitioners fear that the rise of agentic AI means the death of software and UX craftsmanship. I am starting this blog to offer a perspective rooted in a different reality: we are not witnessing the death of our craft, but its remarkable evolution. We are transitioning from a craft-based production model to a supervisory orchestration model. The new skill is not writing the code, it is context engineering.

Entering the Middle Loop

If AI handles the technical execution of drawing a screen or scaffolding a database, where does the engineering rigor go? It moves upstream.

We are entering the Middle Loop, a supervisory orchestration layer that sits between raw code generation and outer-loop deployment. In this space, human intent is becoming the new source of truth. AI models can predict the next pixel or the next line of syntax with astonishing accuracy, but they cannot predict human purpose. They do not possess intrinsic empathy, taste, or strategic judgment.

To thrive in the Middle Loop, UX and engineering leaders have the opportunity to evolve into Architects of Intent. We can move beyond treating design as a static visual export, and elevate it to programmable infrastructure.

Designing the Agentic Canvas

Over the next six or so weeks, I will be publishing a foundational series exploring how we can adapt our practices, workflows, and mindsets to harness agentic velocity and build software reliably at machine speed.

We will explore this transition through six core pillars:

Part 1: The Evolution of Craft
We will explore how the evolution from “Operator” to Intent Architect allows us to delegate high-level goals while maintaining architectural coherence across a fleet of digital workers.

Part 2: Designing the Catalog
AI models don’t have eyes, instead they see grids of floating-point values. We will explore how to solve AI “design blindness” by shifting from static Figma exports to programmable JSON component catalogs and structured DESIGN.md files.

Part 3: The Kaizen of Context
When generation is instant, verification becomes the bottleneck. We will look at why prototyping in production invites us to adopt strict Red/Green Test-Driven Design (TDD) as our ultimate form of prompt engineering and automated validation.

Part 4: The Approval Interface
While perhaps difficult to imagine for those that have yet to experience it firsthand, unmanaged AI fleets create compounding cognitive debt. We will discuss how to design human-in-the-loop orchestration interfaces and UX pull requests to safely review and approve agent actions.

Part 5: Onboarding the Machine
In the agentic era, stale documentation is a major liability. We will explore the daily reality of maintaining the “agent subconscious” and preventing context drift by rigorously curating AGENTS.md files (e.g. CLAUDE.md, GEMINI.md, etc).

Part 6: The Mythical Agent Month
Finally, we will look at the challenges of scaling AI fleets. Without human judgment, agents can easily generate technical debt and “slop forks” at unprecedented speeds, proving that an Intent Architect is more vital than ever.

Code as Craft, Reimagined

The silos separating Product Management, Engineering, and UX are blurring. But your expertise is not obsolete, it has simply shifted up the abstraction stack. The future belongs to those who adopt the learner’s mindset, who can articulate exactly what they mean in machine-readable formats, and who aren’t afraid to get their hands dirty engineering human-AI collaboration.

Hello world. Let’s learn by doing.