The $450 Experiment: Why AI Still Can't 'See'
(And the Economics of Agentic Failure)

10 minute read - October 18, 2026

If you spend any time listening to industry leaders or watching modern AI demos, you get a very distinct impression: fully autonomous, end-to-end agentic engineering is already here. The narrative suggests you can hand a product requirement to a multi-agent loop, walk away, and come back to a production-ready application.

As an engineering leader, I am relentlessly optimistic about what agentic AI represents for our industry. But optimism without empirical rigor is just marketing hype. To truly leverage these tools, we have to test them under real-world conditions.

So, I started a side-of-desk experiment. The goal for this experiment was simple: achieve true end-to-end agentic development without human intervention, and see if the current state of AI could actually pull it off.

To test this effectively, I intentionally chose a customer-facing, frontend-heavy application (replatforming a legacy ASP.NET MVC site into a modern Next.js architecture across four core pages: Home, About, Work, and Contact). Choosing a visual interface wasn't just about the code; it was a deliberate communication strategy. Because user-facing apps are visual, it is vastly easier to demonstrate and communicate architectural friction, UX flaws, and design system breakdowns to non-technical stakeholders and delivery managers—whereas backend architectural decay is often hidden behind abstract API contracts.

I configured a structured multi-agent loop: a Planning Agent (armed with strict tech stack transition rules and detailed business requirements), an Execution Agent (to build out the application), and a Quality Assurance Agent (to audit the results).

The experiment ran to completion. But the results exposed a massive chasm between AI marketing demos and software engineering reality. It cost me 45,000 GitHub Copilot AI Credits ($450.00 USD), forced me to completely rethink how we approach automated workflows, and taught me harsh lessons about why human engineering governance remains non-negotiable.

Here is the post-mortem of my first real attempt at agentic development.

I. The Economics: The Real Math of AI, Tokens, and Offshore Velocity

To evaluate agentic tools as an engineering leader, you have to look past the surface-level marketing and examine the true market economics of software delivery:

The Token Bill: Over the course of the experiment, running the autonomous multi-agent pipeline across those four core pages consumed roughly 45,000 GitHub Copilot AI Credits ($450.00 USD) in direct API consumption.
The Development & Oversight Labor: I spent roughly 8 hours actively prompting, reviewing, and micro-correcting the agent loop. Benchmarked against a standard average offshore developer rate (such as junior-to-mid talent starting around an average of $24/hour), that oversight represents another $192.00 in labor value.
The Total AI-Assisted Cost: Combining the token expenditure and my hands-on engineering time brought the total cost of my autonomous approach to $642.00.
The Traditional Offshore Baseline: Historically, outsourcing this exact 4-page scope (Home, About, Work, Contact—estimating roughly one day per page, or 32 hours total) at a standard offshore average rate of $24/hour would have run $576.00.
The Modern Offshore Reality: The economic landscape has shifted even further. Today’s global development teams and offshore partners are also heavily utilizing AI. When an external agency integrates AI tooling into their workflow, they don't bill you separately for tokens or API credits; they bake that efficiency into reduced delivery times. With AI-augmented acceleration, an experienced offshore team can typically compress that same 4-page scope down to roughly 2.5 days of development work (20 hours). At the $24/hour average baseline, that modern AI-augmented baseline drops to just $480.00.

When you look at the macro picture, the financial reality becomes stark. Doing it yourself with unguided multi-agent loops cost $642.00 and produced an unfinished product with unmaintainable code. Meanwhile, a modern offshore team leveraging AI efficiently delivers the same scope for $480.00 with professional governance. Throwing autonomous agents at a legacy migration without a structured system isn't just an engineering trap—it's economically upside-down.

II. The Anti-Pattern: Falling into the Batch-Review Trap

My initial strategy was flawed from the start. Because I assumed the agents could operate independently, I let the pipeline execute its workflow end-to-end, reviewed the resulting product, and compiled a detailed bug report containing 10+ issues at a time with clear, exhaustive descriptions. I would hand that list back to the agent and expect a comprehensive fix.

The agent would attempt a patch, and upon reviewing it, I would find 10 more issues layered on top of the old ones.

Mid-stream, I realized that AI requires an extremely atomic, single-issue feedback loop. But managing that micro-feedback loop required my constant, unbroken involvement. Far from removing the human from the loop, the agent had turned me into an exhausting manual QA bottleneck.

Results After Agentic Loop — Results After The Agentic Loop

III. Where AI Stumbled: Visual Blind Spots & Architectural Rot

When we hit complex UI elements and micro-interactions—such as the site's signature dial control used for navigation—the experiment broke down completely, highlighting three fundamental limits of current AI:

1. The "AI Cannot See" Problem (And Why Playwright Isn't Enough)

Text tokens, DOM trees, and token streams cannot replicate human visual perception. Consider a specific use case from the site: when a work showcase is open, the navigation dial transforms into an X icon. Clicking that X closes the item, causing the dial to transition back to the main navigation and snap into the center using an elastic easing curve.

Expected Dial Animation

AI completed migrating the dial control, but there was a subtle twitch occurring for this use case. The underlying issue was a race condition: a twitching dial control occurred because multiple animations ran simultaneously - the new page was transitioning in while the dial was snapping back to the center.

I iterated on this issue multiple times with the AI. I described the twitching in detail. The agent repeatedly responded that it "sees" the issue, deployed automated browser tools (like Playwright) to visually verify it, and attempted fixes. Yet, no matter how many loops it ran, it could not resolve the underlying UI race condition.

This is where I rolled up my sleeves as a hands-on manager and stepped in directly. I diagnosed the root cause of the race condition, restructured the logic to ensure the animations ran sequentially rather than concurrently, and eliminated the bug myself in just 5 minutes.

The takeaway: AI models can use tools to capture screenshots or DOM snapshots, but confidently telling you it "sees" an issue is not the same as human visual comprehension. It lacks the real-time perceptual feedback loop required to finesse fluid, frame-by-frame UI animations.

Dial Twitch That AI Cannot See. Can you spot it?

2. Misunderstanding Legacy Human Architecture

One of the most jarring moments was watching how the agent handled clean, human-written patterns. The legacy codebase followed object oriented programming and had a beautifully defined "Class" that encapsulated the complex UI states for poly graphics. The AI ingested this and flattened it into a sprawling, monolithic mess of cascading useEffect hooks tucked inside a single component, completely stripping away the clarity and intent of the original architecture.

3. The Readability & Code Bloat Trap

I tell most of my engineers "to code as if the person that will be maintaining your code is a violent psychopath that knows where you live". Agentic AI evidentially does not follow this belief since generative agents dump thousands of lines of code into files without keeping human maintainability in mind. While human engineers intentionally abstract logic across modular services, custom hooks, and clean boundaries so teams can reason about the codebase, the agent generated a wall of procedural code.

IV. The "90% Done" Illusion and the Decision to Start Over

Eventually, after a dozen iterations and manual interventions, we reached a point where the site looked "close enough" for a human to take over.

During one of my conversations with my delivery manager I expressed my excitement with this experiment. And naturally the conversation shifted to my observation that the AI agents did not get to the finish line. Instead, I mistakenly mentioned that "the AI agent got roughly 90% of the project complete".

The catch? That remaining 10% was going to take longer than building it from scratch.

Expected Results

Outcome After 30 Agentic Loop Iterations - Looks 90% There!

When I finally opened the codebase to inspect that final stretch, nothing made sense. I found myself repeatedly asking the agent to explain its own generated logic because the cascading prompt iterations had turned the code into unmaintainable spaghetti. The clean, human readable, and beautifully structured code was gone.

That was the moment I realized it was time to pull the plug, throw the code away, and start over.

V. Key Lessons Learned

This first real-world attempt at agentic development shattered a few illusions and crystallized two critical takeaways for engineering leaders:

Humans Are Still Required in the Loop: Industry builders often emphasize that AI is an incredible co-pilot, but true "hands-off" autonomy is currently an illusion for anything beyond trivial scaffolding. Human engineering judgment, architectural intent, and visual perception cannot be outsourced to a token stream.
Start Small and Build the Guardrails: When modifying your team's software development lifecycle (SDLC) to incorporate AI, start very, very small. At a minimum, ensure you have all the traditional software development guardrails in place—and ideally, your team should have a mature CI/CD process and automated verification loops before letting agents anywhere near your codebase.

My first experiment with agentic development proved that unguided, multi-agent loops are currently an expensive, high-friction way to generate technical debt. AI is an extraordinary assistant, but without a strict visual and systemic harness, it is a poor architect.

Code generation is cheap; architectural clarity, domain translation, and maintainability are expensive.

This experiment proved that throwing agents at a legacy migration without proper guardrails is a financial and architectural trap. In my next article, I’ll detail how to shift from chaotic vibe-checking to a structured Agentic SDLC—introducing context engineering, deterministic validation loops, and production governance for enterprise engineering teams.