The middle of software work is collapsing.
For most of my career, the middle was where everything happened. You had an idea. You shipped something. But almost all the effort lived between those two moments — writing code, debugging, translating intent into implementation across handoffs and revision cycles.
That middle absorbed most of the time, most of the talent, and most of what we called craft.
AI agents are compressing it.
If the evidence already suggests that AI is becoming standard design infrastructure, the relevant question is no longer whether to adopt it. It is how to remain consequential alongside it.
The grief nobody is naming
Nobody wants to say this, so I will.
The grief designers are feeling right now isn’t about losing their jobs.
It’s about discovering that what they thought was craft was closer to execution.
For 20 years, design was gatekept by tools. Photoshop took months to learn. Figma changed that. AI changed it again. Each time the barrier dropped, the population of “designers” expanded — and what the word actually meant got blurrier.
What AI revealed is not that designers are replaceable. It revealed that a significant portion of design work was always pattern assembly. Visual hierarchy. Spacing. Color application. Consistent component usage. These are learnable rules. AI learned them faster.
The identity crisis runs deeper than the career crisis.
Designers spent years building self-concept around taste, craft, and execution. The portfolio. The reverence for process. The way seniority got measured in delivery. Then a model trained on Dribbble screenshots matched the output.
That’s not a job threat. That’s an existential one.
What’s harder to admit is that responding to it requires more than picking up new tools. It requires letting go of a professional identity built around making the artifact. That is not a minor strategic adjustment. It is an identity crisis dressed up as a career pivot.
The people shouting loudest about AI’s limitations in design are, almost without exception, the ones whose portfolios look most like what AI produces best.
The ones who are quiet are working at a level AI hasn’t touched. Org dynamics. Trust architecture. The political read on why a product keeps getting rebuilt. The ability to tell a founder that the problem isn’t the interface.
That work was never visible in a portfolio. It never won Awwwards.
It just made products work.
The contraction isn’t punishing bad designers. It’s exposing a definition of design that was always too narrow.
The two edges
When the middle compresses, what’s left?
The front edge: What actually needs to be built. What problem is being solved. Shaping work clearly enough that an agent can act on it — and fail usefully when the direction turns out to be wrong.
The back edge: Whether the output solved the problem. Whether the thing that got built should ship. Whether to keep going or change course.
These edges require judgment. Agents don’t have it.
What agents have is execution speed. They build exactly what you ask for. They don’t question whether it’s the right thing. They don’t notice that three feature requests are really one underlying user need. They don’t push back when the brief is solving for the wrong metric.
The shift underway is from producers to directors. The question is no longer How do I accomplish the goal? It becomes What are the goals I want to accomplish, and how do I delegate those goals to AI?
The front edge is the work that now determines everything downstream.
Three positions that hold
Not every designer will reposition the same way. But three orientations seem defensible in this environment.
The first is direct integration — using AI in production workflows to increase output and exploratory capacity, while retaining clear responsibility for the decisions that shape the work. The designer as a highly leveraged director of AI execution.
The second is a pivot toward interpretation, coordination, and evaluation over artifact generation. Less time producing screens, more time synthesizing research, pressure-testing directions, and evaluating whether outputs actually solve the right problem.
The third involves anchoring practice in domains where the cost of error is high enough that automated outputs cannot be accepted without expert oversight. In healthcare, financial services, critical infrastructure — anywhere the failure mode is serious — judgment is not just valuable. It is mandatory.
Each of these is a version of the same underlying move: shifting professional value away from production and toward judgment.
Which sounds like an upgrade. Until you realize the profession spent decades building its identity around production.
What’s missing isn’t capability
Here’s the infrastructure question most design organizations haven’t answered yet.
Designers can already act on front-edge judgment directly. Tools like Cursor, Claude Code, and Cline let them scaffold real components, wire up real data, and iterate on real interactions. That’s not theoretical — designers are doing it today.
What’s missing isn’t capability. It’s environment.
Your design team doesn’t need exclusively Figma files. They need a sandbox repo.
A 1:1 clone of your production frontend. Same components. Same design system. Same lint rules. Same context files, agent configs, and tooling — but the backend is entirely mocked. API calls return realistic data that mirrors your actual schemas. Auth is simulated. Third-party services are stubbed.
A CI job syncs frontend changes from production. Mock data auto-generates from your API specs so nothing drifts. The sandbox stays current without manual maintenance.
No broken builds. No merge conflicts. No accidental production deployments.
Just real, shippable work — in a safe environment.
Not a playground. A contract validator.
Here’s the reframe that matters.
A sandbox repo isn’t a place to experiment. If prototypes use the same tokens, components, and lint rules as production, you’re not designing ahead — you’re stress-testing the system.
Every design decision gets validated against real constraints before it touches an engineering queue. Not wireframes. Not Figma prototypes. Code that follows the same rules as the thing that ships.
That changes the handoff entirely.
When the prototype is done, the code is at least 70% production-grade. Engineering reviews it and ports to prod. The translation layer between what design intended and what engineering built practically disappears.
One thing most teams miss: enforce domain boundaries in the sandbox. No direct API calls. Typed mocks. Feature flags that mirror production toggles. If you skip this, you’ll build beautiful demos that bypass real constraints — interfaces that look right but can’t exist under production conditions.
The sandbox works because the constraints are real. That’s what makes the output trustworthy.
Hackathons produce demos. Sandboxes produce work engineering can actually use.
This isn’t about designers writing code
It’s about designers directing AI agents in an environment that produces production-adjacent output.
The distinction matters. A designer using Cursor in a sandbox isn’t replacing an engineer. They’re collapsing the distance between intent and implementation — doing the translation work that used to happen across multiple handoffs and revision cycles, before it becomes someone else’s problem.
It’s also not a fixed workflow. The sandbox can integrate Figma MCP, third-party design tokens, or whatever tooling your team already uses. The infrastructure is the point, not the specific tools.
Judgment is the territory
When the middle disappears, two things become more valuable — not less.
Forming the right intent. What should we build and why? Who is this for? What does success look like? That judgment doesn’t get automated. Agents need it as input.
Evaluating the outcome. Does this solve the problem? Should we ship this? Is this actually better? That judgment closes the loop.
The work between those two moments — translation, handoffs, revision cycles — compresses. The judgment at both ends expands.
Here is the part worth sitting with: judgment does not live inside prompts. It was built from years of navigating bad briefs, difficult clients, and contradictory constraints. It was earned through the pattern recognition that comes from shipping things and watching them fail in ways no one predicted. That is not something a model trains its way into.
Artificial intelligence does not eliminate the need for design expertise. It relocates it — somewhere less visible, more contested, and arguably more important than it has ever been.
The irony is that it took automation to make that visible. For most of design’s history, judgment was bundled inside production. You couldn’t see it separately because it was always attached to something you could point to. Strip away the artifact, and what remains is the thing that was doing the actual work all along.
The sandbox is infrastructure for that judgment. It gives design teams a place to test intent against reality, fast, without waiting for an engineering sprint to find out whether the idea held up. That is where the leverage is now.
Whether that counts as good news depends almost entirely on where you were planning to stand.
This is part of a series on the future of work with AI agents. Next: About Craft, Taste, and Speed — what separates AI-generated work from work that earns trust.
Daniel Arevalo is Product Experience Lead at Omny Security. He builds AI-native tools and writes about design, product leadership, and what it means to direct systems that execute at a speed humans never had before.