Manoj Aggarwal has built software at Microsoft, Twitter, and Stripe over a 14-year career. In late July 2026, he told Business Insider that AI coding assistants have transformed his workflow—he now spends more time writing prompts than lines of code, and occasionally works at what feels like a 10-times-faster pace. But the veteran engineer also delivered a sobering message: the same tools that supercharge his productivity are shrinking the demand for junior developers, risking the industry’s talent pipeline.

Aggarwal’s account, published as an as-told-to essay, offers a rare window into the practical, career-altering effects of AI coding tools. While the hype often focuses on whether AI will replace developers entirely, his story reveals a more nuanced shift. AI is not eliminating engineering jobs; it is reordering them—amplifying the value of experienced engineers who can direct and verify machine output, while squeezing out the roles traditionally held by newcomers who wrote the routine code now handled by bots.

From Typing Code to Steering Machines

Aggarwal’s daily work looks nothing like it did two years ago. “My coding time has essentially been reduced to writing prompts for AI tools,” he said. He uses Claude Code, Microsoft Copilot, and Lovable, spending roughly $50 to $60 a month on Claude Code alone. For a recent personal project, he tested Anthropic’s Fable model—an experimental, fast variant that impressed him with its speed.

The result is a dramatic acceleration of individual tasks. Boilerplate, unit tests, documentation, and even exploratory prototypes now emerge from AI agents in minutes rather than hours. For a senior engineer with deep system knowledge, this means he can focus on architecture, constraints, and the hard calls that AI cannot make—like why a particular service must preserve an awkward dependency, or how a change could ripple through customer workflows.

But the speed comes with a profound shift in responsibility. “Engineers—not AI—are ultimately accountable for the code that gets shipped,” Aggarwal emphasized. That accountability grows heavier when AI generates large patches that must be reviewed, tested, and validated. The cognitive load of inspecting code you didn’t write—code that looks plausible but may hide subtle bugs—has become a new source of fatigue.

The Junior Squeeze: Why Entry-Level Hiring Is Fading

The most striking part of Aggarwal’s message is the impact on junior engineers. “If 10 engineers were needed to ship a project two years ago, maybe only five are needed now,” he told Business Insider. During his own job search last year, he noticed far more openings for senior roles than junior ones.

This isn’t surprising when you look at what junior developers traditionally do. They take on scoped, low-risk tasks: fixing small bugs, adding simple features, writing test cases, updating documentation. These are precisely the assignments that AI coding assistants handle with growing competence. A senior engineer can now direct an AI to produce a first draft of that work, then review and refine it—without ever involving a junior colleague.

The consequences are twofold. First, companies may reduce junior hiring because the routine work that once justified those roles can be done by AI under senior supervision. Second, the apprenticeship path—where newcomers learn by doing and being mentored—becomes harder to maintain. If junior engineers aren’t doing the hands-on work, how do they gain the judgment that only comes from making mistakes, reading code reviews, and absorbing institutional knowledge?

The bar for entry is rising. Aggarwal’s advice to other engineers: “Lean into your experience—both your engineering skills and the institutional knowledge you’ve built.” But for someone just starting out, that institutional knowledge doesn’t exist yet. The result is a chicken-and-egg problem: you need experience to get hired, but you need a job to gain experience.

Senior Engineers: From Producers to Guardians

For experienced developers, the role is evolving from code producer to system steward. Aggarwal spends less time typing and more time verifying, constraining, and directing AI. He must know when the machine is wrong, when a generated patch is too broad, or when a seemingly clean solution would violate a security boundary that only an old-timer remembers.

This shift makes senior engineers even more valuable—but also puts them at risk of burnout. The review burden is real. Reviewing AI-generated code is cognitively different from reviewing code written by a colleague you’ve mentored. There’s no shared context, no back-and-forth discussion during implementation. You must reconstruct the intent after the fact, across changes that may span many files. Aggarwal acknowledged that “the added responsibility of reviewing AI-generated code can contribute to burnout.”

Moreover, measuring productivity becomes trickier. If an engineer closes more tickets because AI wrote most of the code, is the team actually delivering safer software? The industry will need to shift metrics away from lines of code or pull requests and toward outcomes: defect escape rates, incident frequency, customer satisfaction.

What Windows Developers Should Do Now

Aggarwal’s experience carries practical lessons for the millions of developers who work in the Windows ecosystem—using Visual Studio, VS Code, Windows Terminal, WSL, and Azure DevOps. AI coding tools already integrate deeply into these environments through extensions and cloud services. But with that integration comes risk.

First, separate experimentation from production work. Aggarwal built his financial assistant to run locally because he didn’t want to upload sensitive data to cloud AI. For developers, this means scrutinizing what code, credentials, and proprietary data are exposed when an AI tool reads your repository. Many AI coding assistants work by sending snippets or entire files to cloud services; unless you’ve configured local models or private endpoints, your source code may be leaving your machine.

Second, establish clear review gates. Treat AI-generated pull requests as you would code from an unknown contributor. Break changes into small, reviewable pieces rather than letting an agent churn out a massive diff. Use protected branches, mandatory reviews, and automated tests to catch errors early.

Third, invest in your contextual knowledge. Aggarwal stressed that AI lacks “the high-level picture of what a system should look like or why it’s designed a certain way.” That’s your edge. Understand your product’s history, its dark corners, its regulatory constraints, its performance characteristics. The more you can bring to the prompt, the better the output—and the safer the code.

Finally, if you’re a junior developer or a student, don’t panic—but do adapt. Build a portfolio that demonstrates not just code, but judgment: contributions to open source, bug investigations, design discussions, test strategies. Learn to wield AI tools yourself, but use them as accelerators, not crutches. Show that you can review and critique AI output. In a world where code generation is cheap, the ability to validate, debug, and optimize becomes premium.

Managers: Rethinking Teams in the AI Era

Engineering leaders face a delicate balancing act. On one hand, pairing senior engineers with AI can boost throughput dramatically. On the other, over-reliance on this model may starve the talent pipeline. Aggarwal’s observation that only five engineers might be needed instead of ten underscores the temptation to trim junior headcount.

But cutting junior roles entirely is a short-term gain with long-term pain. Without a steady stream of junior developers growing into senior roles, companies will eventually face a gap—and they won’t be able to hire their way out of it easily.

Forward-thinking teams are already creating new apprenticeship models. Instead of assigning juniors only the grunt work that AI can now handle, they give them structured exposure to AI-assisted workflows under tight mentorship. Juniors learn how to craft effective prompts, interpret AI output, catch hallucinations, and integrate generated code into reliable systems. They still make mistakes—but in a controlled environment where learning accelerates.

Managers should also guard against review fatigue. Rotate AI reviewing duties, enforce small PRs, and invest in automated testing and static analysis to offload repetitive checks. The goal is to keep senior engineers focused on high-judgment decisions, not drowning in machine-generated churn.

A Privacy Parable: The Financial Assistant That Stayed Local

One of the most instructive parts of Aggarwal’s story involves a side project: an open-source tax and financial assistant that analyzes credit card statements, investment portfolios, and tax forms. He built it to run entirely on his own machine, not in the cloud, because he didn’t want to upload personal financial information to AI models.

This isn’t just a hobbyist’s quirk. It’s a masterclass in data hygiene. The same principle applies to enterprise development: code repositories may contain passwords, API keys, unreleased product plans, or customer data. Before connecting an AI tool to your codebase, verify where your data goes, whether it’s retained, and who can access it. Many tools offer local execution modes or configurable privacy settings—use them whenever trade secrets or personal data are involved.

Your Action Plan: Adapting Without Burning Out

Aggarwal maintains a sustainable routine: a couple of hours a week, after his toddler is asleep, experimenting with new AI models and building personal projects. He doesn’t live at his keyboard, and he doesn’t chase every tool launch.

For Windows developers at any stage, a similar plan can keep you current without sacrificing well-being:

  • Pick one AI coding assistant (Copilot, Claude Code, Codeium, etc.) and use it consistently for a month on non-critical tasks.
  • Focus on safe, everyday chores first: generating tests, explaining code, documenting functions.
  • Compare its output against your own standards. Note where it saves time and where it introduces errors.
  • Gradually move to more complex assignments, always with human review.
  • Dedicate a fixed, short time each week to explore new tools—not because you must, but because it’s cheaper to learn now than to scramble after a layoff.
  • Remember that your value lies in understanding the system, not in typing speed. The engineer who can ask the right questions and spot a bad answer will always be in demand.

Outlook: The Next Wave Will Force Even Faster Adaptation

Aggarwal’s essay is a snapshot from mid-2026, but the pace of change suggests the story isn’t finished. AI coding agents are moving from generating code snippets to executing entire multi-step tasks—refactoring across repositories, debugging production issues, even proposing architecture changes. As these capabilities grow, the pressure on junior roles will intensify, and the premium on seasoned judgment will climb.

Windows developers who embrace these tools thoughtfully will find themselves more productive and more creative. Those who ignore them risk being outpaced—not by AI alone, but by peers who marshal AI to fill the gaps. The lesson from a 14-year veteran is clear: don’t fight the machine, but don’t trust it blindly. The engineers who thrive will be those who direct AI with wisdom, verify its output with rigor, and build the institutional knowledge that no model can replicate.