Transcription
In February this year, something happened that should have every software engineer, especially in India, paying attention. India's biggest tech stocks, Nifty IT index, dropped nearly 6% in a single day. No warning, just a straight fall. And over the next four trading sessions, it slid almost 9%.
Not a recession, not a geopolitical shock, not a sudden collapse in demand. It was a US tech selloff combined with one product launch that quietly send a chill through the entire market. Anthropic, the company behind cloud AI, launched something called cloud co-work. Cloud co-work isn't one AI. It's 11 specialized AI co-workers each trained to automate a specific type of enterprise work. Legal, compliance, analytics, marketing. 11 AI plugins designed to automate the exact kind of work Indian IT firms make billions billing for.
And the market did the math in real time. If a client sitting in New York can automate contract reviews and compliance tracking internally using an AI tool, why would they pay for a 50% team in Bengaluru to do it? Infosys crashed nearly 8%. LTI Minds down 8%, TCS, Vipro, SCL, Tech Mahindra all bleeding red. Roughly two lakh crores in investor worlds wiped out in hours.
Now some analysts are calling it as a knee-jerk reaction and maybe the market overreacted in the short term but the underlying fear that's very real and to understand why you need to understand something called a software factory. Once you see how it works you will understand why this isn't just another AI hype cycle but also why there's a clear path forward if you are willing to adapt. All right so let's break this down step by step.
A few weeks ago, Justin McCarthy, the CTO of a company called Strong DM, published something fascinating. He described how his team built what he calls a software factory. And the core idea is deceptively simple. In a software factory, humans don't write code. Humans don't even review code. Instead, humans write specifications. what the software should do and scenarios how user should actually use it and then AI agents do everything else. They write the code, test it, review it, fix it, iterate it, and keep going until the software works.
Now, this sounds like a science section, right? So, let me walk you through how they actually got there. Before late 2024, when you asked an AI to write code iteratively, something very predictable would happen. Each iteration would introduce new bugs, misunderstandings, hallucinations, version conflicts. The code base would get worse and worse with each pass. Eventually, it would just collapse and death by a thousand cuts. But around October 2024, with the updated cloud 3.5 model, something flipped. Instead of errors piling up, correctness started piling up. Each iteration made the code better, not worse. McCarthy calls this the shift from compounding error to compounding correctness.
So McCarthy's EI team set one rule on day one. Don't touch the code. Let the agents do everything. How far could they get without writing a single line by hand? Initially, not very far. And here's why. The agents are smart, but they are also lazy in a very specific way. If you tell an agent to make all tests passed, it'll find the quickest way to do that. And sometimes the quickest way is to just write return true. Done. All test pass. Ship it. Obviously that's useless. The code technically passes every test but doesn't actually do anything.
And this is where it gets really clever. They realize traditional tests have a fundamental problem. The test lives inside the codebase. So the agent can just rewrite the test to match its broken code. Problem solved. Well, that's problem hidden. And this is called reward hacking. The AI isn't solving the problem, it's gaming the evaluation. So, McCarthy's team created something they called scenarios. Think of a scenario as a complete user story. A user logs in, creates a project, invites a teammate, the teammate gets a notification. These scenarios are stored outside the codebase. The agent can't touch them, can't modify them, can't cheat, and instead of pass or fail, they measure something called satisfaction. out of a thousand different ways a user might go through scenario. What percentage actually work? It's probabilistic, not binary, just like the real world.
Now, here's the final piece. Strong DM software integrates with services like Octa, Jira, Slack, Google Docs. To run thousands of scenarios, you need to hit these APIs thousands of times. You would hit the rate limits, trigger abuse detection, rack up enormous cost. So they built something extraordinary. Full behavioral clones of these services. A fake octa, a fake Jira, a fake Slack. Each one replicating the real API, including edge cases and error behaviors. They call this the digital twin universe. And with it, agents can run thousands of scenarios per hour. No rate limits, no API cost, no risk.
Here is the insight that matters. Building a full replica of Octas API was always technically possible. But no engineering manager would ever approve it. It would take months. The costbenefit math didn't work. But in software factory, the agent build the clones too. What was unthinkable 6 months ago is now routine. So that's the software factory. Specifications go in, working software comes out. Humans supervise, but they never touch the code. And here is what McCarthy says about economics. If you haven't spent at least $1,000 on tokens today per human engineer, your software factory has room for improvement. Let that sink in. The metric isn't how many lines of code your engineers wrote, how many AI tokens they consume.
In Google, over 25% of all new code at Google is written by EI. That number was from late 2024. It's almost certainly higher now. Satya Nadella said AI is composing 30% of Microsoft code. Salesforce CEO paused engineering hiring entirely citing a 30% productivity boost from AI tools. Mark Zuckerberg said AI will take on mid-level engineering task.
And then there is the one that really caught my attention. Sergey Brin, Google's co-founder, recently spoke at Stanford and said something that sent shock waves through the industry. He said Google is now hiring tons of people who don't have bachelor's degree. People who in his words just figure things out on their own in some weird corner. Google the company that used to hire exclusively from Stanford, MIT, IITs, now saying skills and the ability to figure things out matter more than your degree. And the data backs this up. In 2017, 93% of Google's job posting required a degree. by 2022 that had dropped to 77% and is still falling.
When someone asked Brian about studying computer science given AI can write code, his response was brilliant. He said, I wouldn't go switch to comparative literature because you think AI is good at coding. The AI is probably even better at comparative literature. The point isn't that coding is dead. The point is that nature of what's valuable has fundamentally changed.
Okay, so let's talk about what this means for India because this is where it gets personal. For 30 years, India's IT outsourcing model ran on one simple equation. Western companies needed software work done. Indian engineers could do it at a fraction of cost. Why pay one American engineer $150,000 when you can get five Indian engineers for the same price? That equation built at $283 billion industry. It built Bangalore. It built Hyderabad. It build careers for millions of families.
But software factories break that equation completely because they don't need cheaper engineers. They need fewer engineers. Period. If a company in San Francisco can write away a factory where AI agents write, test and ship code without any human touching it. Why would they outsource anything and the market already sees this? When cloud co-work launched, Indian IT stocks didn't just dip, they crashed. Because investors looked at those AI plugins and asked the obvious question. If a client can automate legal reviews, compliance tracking, and data analysis internally, what are they paying Infosys for? The old model sold human hours at lower cost. The new model doesn't need human hours at all.
Now, I'm not saying 5 million jobs vanish overnight. Enterprises still need integration, governance, complex system orchestration. But the base of the pyramid, the routine cing, testing, bug fixing, documentation that freshers and junior engineers do, that's exactly what these factories eat first. The trend is clear. The only question is what you do about it.
So let's go back to the software factory and ask the most important question. Where are the humans? They're not writing code. They're not reviewing code. So what are they doing? They're writing specifications. What should the system do? What are the edge cases? What happens when things go wrong? They are designing scenarios. How does a real user move through this product? What are the thousand paths that need to work? They're building digital twins, understanding APIs so deeply, they can create behavioral clones of entire services. They are evaluating whether the AI's output actually works in the real world. The value isn't in writing code anymore. It's in knowing what to build, why it should work, and how to verify that it does. That's system design and that's what separates the engineer who designed the factory from the engineer the factory replaces.
So here is what I really want you to take away from this video. Most engineers right now are consumers of AI. They use chat GPT to debug code. They use copilot for autocomplete. They paste errors into cloud and ask for fixes. That's fine as a starting point, but it's not a career strategy. Because if all you do is consume AI, you're still doing the same job, just slightly faster. And slightly faster is not a mode. The software factory will still automate your role.
The mindset you need is a producer mindset. A producer doesn't use AI to write code faster. A producer builds systems where AI works for them. They design the specifications. They architect the evaluation frameworks. They orchestrate the agents. McCarthy at strong DM didn't ask AI to help him code. He built a entire factory where AI writes, test, and ships code without him. That's a producer. He designed the system. So ask yourself honestly right now today, are you just consuming AI or are you producing with it? Are you using AI to do the same job slightly faster or are you using your understanding of systems to build something AI couldn't build without you? That question will decide your career over the next few years. So learn AI deeply, not prompts and tricks. Understand how agents work, how to orchestrate them, how to evaluate their output, and invest in system design. Understand distributed systems, architecture, fall tolerance, because that's what software factories need as input. That's the human contribution that isn't going away. Be a producer. Build the factory. Don't be the thing the factory replaces.
If this video made you think, share it with an engineer friend who needs to hear this. And if you want to start building the kind of deep system design and AI knowledge that makes you irreplaceable, you know where to find me. I'll see you in the next one. >> [music]