Forem: Tahmid Khan A

The AI Code Deluge: Why We're Drowning in Technical Debt

Tahmid Khan A — Wed, 11 Feb 2026 13:36:40 +0000

It’s February 2026. The hype cycle has shifted again. We’ve moved past the "Chatbot" phase and firmly into the "Agentic" era. OpenAI, Anthropic, and Microsoft are selling us a dream: autonomous coding agents that live in your IDE, understand your entire repo, and ship features while you sleep.

If you believe the marketing, software engineering as a discipline is about to be "solved."

But if you look at the actual state of codebases in 2026, a different reality is emerging. We aren't just shipping features faster; we are generating technical debt at a velocity that human teams cannot sustain.

We are witnessing the rise of AI Productivity Theater. And if we don't change how we use these tools, we're going to drown in a sea of mediocre, unmaintainable code.

The Illusion of Velocity

I spent the last week auditing a project that had "heavily adopted" AI workflows. The team was proud. Their commit volume was up 300%. Tickets were moving from "In Progress" to "Done" in record time.

On the surface, it looked like a hyper-efficient machine.

Then I opened the code.

It was a sprawling mess of disconnected logic. Functions were duplicated because the AI didn't know a utility for that already existed in utils/. Components had slightly different styling implementations because three different prompts generated them. Error handling was generic—lots of try/catch blocks wrapping massive chunks of logic, logging e to the console, and failing silently.

The code worked. The tests (also written by AI) passed.

But the architecture was rotting.

This is the trap. AI is fantastic at the micro (writing a function, fixing a regex, generating a test case). It is terrible at the macro (system cohesion, data flow consistency, long-term maintainability).

When you let an autocomplete engine drive your architecture, you get exactly what you'd expect: a system that looks like a patchwork quilt of Stack Overflow answers, stitched together with confidence but no comprehension.

The "Senior Review" Bottleneck

Here is the dirty secret of 2026: Code Review is dead.

Or rather, effective code review is dying.

In the old days (circa 2023), a Junior Dev would submit a PR with 50 lines of code. A Senior would read it, spot a logic error, and explain why it was wrong. That was the feedback loop. That was mentorship.

Today, an "AI-Augmented" Junior submits a PR with 500 lines of code. It looks clean. It follows the linter rules. The variable names are descriptive.

But to verify if it's actually correct—to check for race conditions, edge cases in state management, or security holes—the Senior has to mentally reconstruct the entire logic flow.

And they don't.

It takes too much energy. When the code looks right, the brain skims. We approve the PR. We merge the debt.

We are replacing "Junior Developers" with "AI Agents," but we are forgetting that Juniors grow up to be Seniors. Agents don't. Agents don't learn from your architecture; they just statistically predict the next token. They will make the same architectural mistake a thousand times if you let them.

Case Study: The "Refactor from Hell"

Let me tell you a story about a startup I consulted for last month (names changed to protect the innocent). They were building a fintech dashboard. They used a popular "Agentic IDE" to scaffold the entire backend in a week.

"It saved us two months of dev time!" the CTO told me.

The backend was built using Python and FastAPI. It had 40 endpoints.

When I looked closer, I found 14 different ways of connecting to the database. Some endpoints used an ORM. Some used raw SQL strings (generated by the AI). Some used a deprecated driver that the AI hallucinated was the "standard."

Why? Because different team members used different prompts at different times, and the AI just gave them whatever was statistically likely for that specific prompt context. It didn't look at the other files to see how the connection was already established.

When they tried to migrate the database schema, everything exploded.

The "two months saved" were immediately spent on a painful, month-long rewrite where humans had to go in and untangle the AI's spaghetti.

This is the Hidden Tax of AI code. You don't pay it when you write the code. You pay it with high interest when you try to change it.

The Security & Compliance Minefield

Beyond architecture, there's a looming security crisis.

I recently saw a codebase where an AI agent had helpfully imported a package called azure-sdk-python-core. Sounds official, right?

It wasn't. It was a typosquatted malware package.

The AI didn't "know" it was malware. It just saw that azure-sdk and python-core often appear together in its training data, and hallucinated a package name that sounded plausible. Because the package actually existed on PyPI (registered by an attacker), the install succeeded.

Furthermore, we are pasting massive amounts of proprietary business logic into context windows. "Sovereign AI" is the buzzword of 2026 for a reason—enterprises are terrified. But developers are lazy. If the local model is dumb, they will paste the code into the smart cloud model.

We are leaking our IP, bit by bit, into the training datasets of the future.

The Death of the "Tinkerer"

This brings me to the saddest trend I see on Reddit and Hacker News: the despair of the entry-level market.

Companies are freezing hiring for juniors because "AI can do that work."

This is short-sighted suicide.

A Junior Developer isn't just a "ticket closer." They are a future architect in training. They learn by breaking things. They learn by struggling through a weird dependency conflict. They learn by writing a slow query, taking down production, and fixing it.

If you outsource the "struggle" to an AI, you outsource the learning.

We are raising a generation of "Prompt Engineers" who can summon a React component in seconds but can't debug a memory leak because they have no mental model of how the DOM actually works. They know the syntax of the solution, but not the mechanics.

When the abstraction leaks—and it always does—they are helpless.

A Survival Guide for the AI Age

So, am I a luddite? Am I saying we should go back to writing assembly on stone tablets?

No. I use these tools every single day. My productivity is higher. But my process has changed. And yours needs to, too.

Here is the Senior Engineer's Manifesto for AI:

1. Treat AI as a Junior, Not a Guru

Never ask an AI to "design" a system. Design it yourself. Draw the boxes. Define the interfaces. Then, and only then, ask the AI to implement the specific implementation details inside those boxes.

You are the Architect. The AI is the bricklayer. If you let the bricklayer decide where the walls go, you're going to end up with a house that has no doors.

2. The "Explain It To Me" Rule

When an AI generates code for you, do not commit it until you can explain exactly what every line does. If there is a regex you don't understand, ask the AI to break it down. If there is a library import you don't recognize, Google it (don't ask the AI, verify it externally).

If you commit code you don't understand, you are not a developer. You are a copy-paster.

3. Mentorship > Automation

If you manage a team, don't let your juniors use AI to bypass the struggle. Encourage them to use it to explain concepts ("Explain why this useEffect is triggering twice"), not to solve them ("Fix this useEffect").

The goal is to build mental models, not just software.

4. Code Deletion is the New Productivity Metric

In an age where generating code is free, the value of code approaches zero. The liability of code approaches infinity.

Celebrate the PRs that delete code. Celebrate the refactors that simplify logic. Use AI to find dead code, to consolidate duplicates, to generate documentation—tasks that reduce entropy, not increase it.

The Verdict

The flood of AI-generated code isn't going to stop. Tools like the Model Context Protocol (MCP) are only going to make it easier to generate massive PRs with a single click.

But software engineering isn't about writing code. It never was.

It's about managing complexity.

Right now, AI is the greatest complexity generator we have ever invented. Our job, more than ever, is to be the filter. To be the ruthless editor. To say "No" to the easy, generated path and "Yes" to the hard, thoughtful architecture.

Don't let the tools fool you. Speed is not quality. And in 2026, the most valuable developer isn't the one who writes the most code—it's the one who knows what code not to write.

Originally published at Rebound Bytes. No fluff, just code.

AI Agents Are Productivity Theater (And That's Fine)

Tahmid Khan A — Tue, 10 Feb 2026 19:14:15 +0000

The era of AI agents has arrived. Or so we're told.

If you've been anywhere near tech Twitter, Hacker News, or Reddit in the past year, you've seen the hype train. Autonomous AI agents will replace your workforce. They'll book your travel, answer your emails, write your code, and probably do your laundry if you ask nicely enough.

The reality? Most AI agents are expensive toys solving imaginary problems.

But here's the twist: the ones that actually work are changing how we build software—just not in the way the marketing teams want you to believe.

The Agent Hype Cycle: Where We Are Now

February 2025 marked the peak of what I call "agent theater." xAI launched Grok 3, Google DeepMind shipped Veo 2, and every startup with a ChatGPT wrapper pivoted to calling themselves an "agentic AI platform."

The demos were slick. The valuations were insane. The actual utility? Questionable.

Here's what the research showed (and yes, I pulled this from real discussions on HN and Reddit):

Hardware is the real story: Microsoft's quantum chip progress and Toyota's solid-state battery breakthrough got buried under AI noise
Developer fatigue is real: AI-generated documentation began outranking official docs in search results, making Stack Overflow practically unusable
Security nightmare: Gmail phishing scams using AI-cloned voices jumped 300% in Q1 2025

The job market told the real story: entry-level generalist dev roles dropped 25% year-over-year, while specialized AI/ML and cloud security positions increased 15%.

Translation: Companies aren't replacing developers with agents. They're hiring fewer generalists and more specialists to build and secure agent systems.

What Actually Works: The Boring Stuff

Strip away the hype, and AI agents excel at three things:

1. Glorified Automation Scripts (With Context)

The best agents I've seen aren't sentient workers. They're context-aware automation layers.

Example: A customer support agent that:

Reads your ticket history
Checks your account status
Pulls relevant docs
Drafts a reply for a human to review

Is this revolutionary? No. It's a smart database query + template engine.

Is it useful? Hell yes. It cuts response time from 45 minutes to 3 minutes.

The difference between this and a traditional workflow automation tool? The agent understands intent. You don't need to hardcode every possible ticket type—it generalizes from examples.

2. Natural Language as an Interface Layer

This is where agents shine: making complex systems accessible without learning SQL, regex, or whatever arcane syntax your enterprise dashboard requires.

You want last quarter's revenue broken down by region? Just ask.

Previously, this required:

Finding the right dashboard (30 min)
Remembering the filter syntax (10 min)
Exporting to Excel because the UI is garbage (5 min)
Manually aggregating because the export format is different than expected (15 min)

Now? "Show me Q4 revenue by region" → instant Markdown table.

The underlying data pipeline hasn't changed. The interface friction disappeared.

3. Tedious, High-Volume Tasks Nobody Wants

PR reviews for style violations. Scheduling meetings across six time zones. Parsing vendor invoices.

These tasks don't need AGI. They need a tireless junior employee who doesn't get bored.

Agents are perfect for this. They're consistent, they don't complain, and they cost pennies compared to human hours.

But here's the catch: you still need humans to define "good."

An agent can flag PRs with inconsistent naming. It can't decide whether your team's naming convention is stupid in the first place. That's still a human judgment call.

Why Most Agent Startups Will Fail

The problem isn't technical capability. It's use case mismatch.

Most agent platforms are built like Swiss Army knives: technically impressive, but not actually great at anything specific.

Example: A "general-purpose" scheduling agent that can:

Book flights
Reserve restaurants
Schedule meetings
Order groceries

Sounds amazing. In practice?

Flight booking requires accessing your loyalty accounts (security nightmare)
Restaurant preferences are hyper-personal and change based on mood/context
Meeting scheduling needs org-specific rules (who can decline whom, internal vs external protocols)
Grocery shopping involves dietary restrictions, brand preferences, and the fact that sometimes you just want junk food

Each of these is a deep vertical problem. A horizontal solution will be mediocre at all of them.

The winners will be specialized agents solving one specific workflow better than any human could.

The Real Innovation: Agents as Infrastructure

Here's where it gets interesting.

The best use of AI agents isn't replacing jobs—it's replacing middleware.

Think about how modern web apps work:

Frontend calls API
API validates request
API queries database
API formats response
Frontend renders data

Now imagine an agent layer that:

Interprets natural language queries
Translates them to API calls
Aggregates data from multiple sources
Formats output based on user context

You've just replaced half your backend boilerplate with a reasoning layer.

This is already happening. Perplexity and OpenAI's search prototypes aren't just "better Google"—they're API orchestration engines disguised as search.

You ask: "What's the cheapest flight to Tokyo next week?"

Behind the scenes:

Searches multiple airline APIs
Cross-references with hotel availability
Checks visa requirements
Factors in your calendar (if integrated)
Returns a synthesized answer with booking links

That's not search. That's a distributed system with a conversational interface.

The Enshittification Problem

Here's the dark side: as agents get better at looking useful, they're also getting better at producing garbage.

The "enshittification of documentation" is real. AI-generated tutorials are flooding search results, written by bots optimizing for SEO, not accuracy.

Real example from Reddit: A developer spent 2 hours debugging a Next.js issue using a top-ranked tutorial. Turns out, the tutorial was AI-generated, referenced outdated APIs, and had never been tested.

The problem compounds:

AI generates plausible-sounding content
Google ranks it highly (good formatting, keywords, etc.)
Humans read it, assume it's correct
Other AIs scrape it as "training data"
The cycle repeats

We're training future models on synthetic garbage generated by previous models.

This is the "Dead Internet Theory" coming true—not through malice, but through incentive misalignment.

What Developers Should Actually Care About

Forget the hype. Here's what matters:

1. Security Is the New Bottleneck

AI-powered social engineering is terrifyingly good. That 300% spike in phishing attacks? Just the beginning.

If you're building agent systems, authentication and authorization are your #1 priority. An agent with access to your email, calendar, and payment info is a single phishing attack away from disaster.

2. Energy Costs Are Real

Training Grok 3-class models consumes absurd amounts of power. The environmental impact is non-trivial.

If you're deploying agents at scale, inference costs will eat your margins. Optimize for efficiency, not capability.

3. Job Market Is Polarizing

The "learn to code and get a junior dev job" pipeline is broken. Entry-level roles are shrinking because agents handle the grunt work.

But specialized roles—AI/ML engineers, security architects, infrastructure specialists—are booming.

The future isn't "everyone gets replaced." It's "generalists get squeezed, specialists get leverage."

The Uncomfortable Truth

AI agents aren't replacing knowledge workers. They're amplifying the gap between those who know how to use them and those who don't.

A skilled developer with an AI assistant can outproduce a team of 5 juniors. But a junior developer relying on AI-generated code without understanding the fundamentals? They're producing technical debt at scale.

The same pattern applies everywhere:

A marketer with AI tools can A/B test hundreds of variants instantly
A designer can prototype in minutes instead of hours
A researcher can synthesize thousands of papers overnight

But only if they know what good looks like.

Agents don't replace expertise. They multiply it.

Where This Goes Next

The next 12 months will separate the real innovations from the vaporware.

What will survive:

Specialized agents for deep verticals (legal, medical, financial analysis)
Infrastructure-level agent systems (API orchestration, data aggregation)
Security-first agent frameworks (zero-trust, sandboxed execution)

What will fade:

General-purpose "do everything" agents
Consumer-facing scheduling/email bots (too much liability, too little margin)
AI-first startups with no moat beyond a GPT wrapper

Final Take

AI agents aren't magic. They're probabilistic reasoning systems with API access.

That's simultaneously less impressive than the hype suggests and more useful than the skeptics admit.

The winners won't be the companies with the best demos. They'll be the ones solving specific, high-value problems where automation was previously impossible.

And developers? Your job isn't to compete with agents. It's to decide what they should automate, audit what they produce, and fix what they break.

That's not going away anytime soon.

Want to stay ahead of the AI agent curve? Follow along as I break down the tools, frameworks, and strategies that actually matter. No hype, no bullshit—just practical insights for developers building in the agentic era.

Originally published at Rebound Bytes. No fluff, just code.

Waymo's Open Secret: The 'Robot' Taxi Is Just Outsourcing in a Trench Coat

Tahmid Khan A — Mon, 09 Feb 2026 03:25:51 +0000

There is a recurring theme in the history of Artificial Intelligence: if you pull back the curtain on a "magical" new technology, you inevitably find a human being sweating over a keyboard.

First, it was Amazon's "Just Walk Out" technology, which turned out to be 1,000 people in India watching security cameras and manually adding items to your cart.

Now, it's Waymo.

New reports (and admissions from Waymo itself) have confirmed what skeptics have suspected for years: those "fully autonomous" robotaxis navigating San Francisco's complex streets aren't quite as autonomous as the marketing suggests. A significant portion of their "intelligence" is actually beam-streamed from remote centers where human operators—often in lower-cost labor markets like the Philippines—are guiding the cars through tricky situations.

The stock market reacted with a shrug (Alphabet/GOOG is down ~2.5% today, but that's just noise). But for the developer community and the broader public, this is yet another crack in the "AI is Magic" narrative.

The "Human in the Loop" Reality

To be technically fair to Waymo: these remote operators aren't "driving" the cars in the video game sense. They aren't holding a Logitech steering wheel and hitting the gas.

The official term is "Remote Assistance" (RA). When the car gets confused—say, by a construction cone that looks like a person, or a police officer using hand signals—it stops and pings home. A human looks at the camera feed and clicks a path: "Go around the cone on the left." The car then executes the maneuver itself.

Waymo argues this is a safety feature. And it is.

But it also fundamentally changes the economics of the business.

If every "autonomous" ride requires 5 minutes of human attention to navigate a 20-minute trip, you haven't invented a robot taxi. You've invented a very expensive remote-controlled car.

The "Mechanical Turk" Economy

This feeds into a darker narrative about the current AI boom: are we actually solving hard technical problems, or are we just finding new ways to hide low-wage labor behind an API?

Amazon Just Walk Out: "Computer Vision" = Humans watching video.
Customer Service AI: "Chatbots" = Humans editing responses.
Data Labeling: "Self-Supervised Learning" = Millions of workers in the Global South drawing boxes around stop signs for pennies.

We are building a Rube Goldberg machine of labor arbitrage. We sell the service at a premium ("High Tech AI"), pay the labor at a discount ("Remote Gig Work"), and pocket the difference while telling investors we've solved General Intelligence.

Why This Matters for Developers

For those of us building software, this is a cautionary tale about marketing vs. architecture.

We are being sold tools and platforms that promise full automation. "Autonomous Coding Agents" that will build your app. "Self-Driving" databases. "Zero-Touch" infrastructure.

But in production, "autonomous" almost always means "autonomous until it breaks."

The Waymo news is a reminder that edge cases are infinite. You can train a model on a trillion miles of driving data, and it will still freeze when it sees a woman in a chicken costume chasing a duck across a crosswalk (a real thing that happens in San Francisco).

Humans are the exception handlers. And until AI can handle the chicken-duck scenario without pinging Manila, we aren't replacing humans. We're just moving them to a call center.

The Trust Erosion

The real damage here isn't to Waymo's technology—which is objectively impressive—but to public trust.

We were told the cars drive themselves. They don't.
We were told the stores run themselves. They didn't.
We were told the code writes itself. It doesn't (as my last post on AI productivity showed).

We are entering the "Trough of Disillusionment" for the 2020s AI hype cycle. The magic is wearing off, and we're starting to see the wires.

Conclusion

Waymo is still the leader in this space. Their cars mostly drive themselves. But the dream of zero-marginal-cost transportation—where a robot taxi costs pennies because no human needs to get paid—is dead for the foreseeable future.

As long as there's a human in the loop, the cost floor is set by human wages. And as long as we pretend otherwise, we're just lying to ourselves.

Stock Watch: Alphabet (GOOG) sits at $323.10, down slightly. The market knows that even with human helpers, Waymo is miles ahead of Tesla. But "miles ahead" doesn't mean "finished."

What do you think? Is "Remote Assistance" cheating, or just smart engineering? Let me know.

Originally published at Rebound Bytes. No fluff, just code.