Ujjwal Chadha

Dario Amodei said AI could wipe out 50% of entry-level white-collar jobs and push unemployment to 20%. Now, Anthropic's OWN head of economics said he'd seen "no larger material difference in unemployment" for AI-exposed workers 🤦

Everyone is saying “AI is taking software engineering jobs” BUT the largest hiring dataset in tech (SignalFire, 80M+ companies) found engineers were the MOST resilient function in 2025. - Total hiring: down 25%. - Design: down 48%. - PM: down 39%. - Engineering hiring: down ONLY 11%. AI isn’t coming for good engineers anytime soon.

What "AI engineer" actually means in 2026 The AI Conference version, NOT the LinkedIn version: Table Stakes: - Evals & observability - Context/memory engineering - Agent reliability + human-in-the-loop - Inference optimization (quantization, serving) - Tool calling / MCP Quietly Demoted: - Prompt engineering (folded into context) - Plain RAG (now one piece, not the answer) - "Can the agent do it" demos (assumed)

IT services added 110,000 jobs in India last year. GCCs added 200,000 AND paid 30-40% more for similar roles. 3 years ago, it was the other way around. Looking beyond traditional IT jobs at Infosys, TCS, Wipro might now actually be easier and pay more.

@0xShailu I didn’t say it’s a rule. I started with infosys as well to work at Microsoft later. But that’s not the point I am making. Starting with product companies gives you a much better boost.

@ujjwalscript Respectfully, No sir. You can start with TCS and still work in Product based company with good package after 3 years. There are no rules.

The Indian software salary market isn't a ladder. It's a fork. Fresher at TCS: ₹4L Fresher at a product company: ₹8–22L Same degree. Same year. Same skills on paper. The single biggest career decision you'll make is your FIRST company.

15,000 entry-level tech openings in India. 63,000 mid-senior. It's hard to enter the industry AND it pays almost nothing to start, but once you do, your demand skyrockets and so does your wallet.

Stop calling yourself a Senior Developer if you can’t debug without AI! The biggest ego trip in tech right now is "Senior Vibe Coding." Engineers with years of experience think they’ve achieved god-mode because they can prompt a complex feature into existence in 20 minutes. But here’s the brutal reality check: You aren't engineering anymore. You’re just babysitting a very fast, very confident junior dev who constantly hallucinates. When you outsource your core logical thinking to a model, your technical edge begins to atrophy. The illusion of velocity is masking two massive traps: 1. The Reading Tax: Reading code is inherently harder than writing it. When you review 500 lines of AI boilerplate, your brain naturally skims. You miss the subtle, silent edge-case bugs that a human would never write, but an LLM confidently outputs. 2. Debugging Atrophy: The moment production crashes at 2 AM, a prompt won’t save you. If your default response to a complex stack trace is to blindly copy-paste it back into your AI editor hoping for a quick fix, you've lost control of your system.

The "AI makes you a 10x Developer" you keep seeing on X is an ABSOLUTE illusion. And the empirical data finally proves it! The overwhelming consensus right now is that AI coding tools make every developer 10x faster, rendering foundational learning obsolete. Here is what the actual, data-backed reality looks like: 1. The "Time Savings" Illusion: A study by METR tracked experienced contributors tackling tasks in complex codebases. While developers predicted AI would save them 24% of their time, using AI actually increased completion time by 19%. Why? Because models generate syntactically correct code that completely misses broader system architecture, forcing engineers to waste hours debugging out-of-context boilerplate. 2. The Comprehension Trap: A randomized trial by Anthropic analyzed developers learning a new framework. Those who relied on AI to generate their code scored 17% lower on comprehension tests. When you treat AI as a typewriter instead of a sounding board, your brain skips the critical cognitive heavy lifting. 3. The Junior Bottleneck: A Harvard-backed study tracking tech worker records revealed that companies adopting generative AI cut junior developer hiring by 9% to 10%, while senior roles remained entirely flat. AI isn't replacing engineers—it's replacing the entry-level code-typists.

I’ve spent years building production AI features, internal tools, evaluation harnesses, RAG pipelines, and agentic workflows. Yes, AI is not magic! It is a very powerful, very expensive, very brittle multiplier of human intelligence. BUT it only creates durable value when skilled humans do the hard, unglamorous work of defining problems precisely, curating data, iterating on failure modes, integrating into real workflows, measuring outcomes, and maintaining the system over time. Most “AI projects” skip most of that and then wonder why they fail.

GitClear recently analyzed over 211 million lines of code to see what AI is actually doing to our code. The results completely DESTROY the "hyper-productivity" narrative! 1. In 2021, 25% of code changes were refactoring (moving and consolidating code). By 2024, that plummeted to under 10%. Developers aren't taking the time to architect reusable modules anymore; they are just hitting 'Tab' and letting the AI generate another isolated, brute-force function. 2. Commits containing massive blocks of duplicated code skyrocketed by an astounding 800% last year. AI models are trained to predict the next token, not to enforce the DRY (Don't Repeat Yourself) principle. When you are building systems with high-stakes logic - like managing timezone conflicts and concurrent reservations for a sports venue booking platform - this kind of duplicated code is exactly how you introduce catastrophic bugs across different files. 3. Almost 8% of all newly added code is now being reverted or heavily revised within just two weeks of being committed. We aren't writing better code; we are just rapidly generating "mistake code" that has to be manually untangled later. Google’s own DORA report backed this up with a brutal metric: For every 25% increase in AI adoption, delivery stability actually decreased by 7.2%. When managing engineering teams at scale, the takeaway becomes glaringly obvious: AI is a phenomenal typing accelerator, but it is an atrocious software architect. Stop measuring developer productivity by how many lines of code were generated this week. Start measuring it by how many lines you didn't have to write because the system was designed correctly the first time. More code is not a feature. It is a liability.

I met an engineer friend for coffee yesterday who told me he’s getting ready to QUIT Software. He’s a mid-level dev, incredibly smart, but completely burnt out by the doom-scrolling! He said, "Look at the 2026 data, man. Active tech openings are down to a multi-year low. Entry-level hiring has dropped nearly 20%. Eric Schmidt is out here telling everyone traditional coding is dead, and tools like Claude Code can resolve half our production bugs autonomously. What is even the point of trying to compete with a machine that works for pennies?" He genuinely believed the popular consensus: The machines are over, so human developers are obsolete. I let him finish, took a sip of my coffee, and told him he was completely misreading the room. Yes, the market is restructuring. Yes, companies are trimming the fat. But they aren't firing people because they want less software. They are firing the the people whose entire value proposition was copy-pasting boilerplate, writing routine unit tests, and manually building CRUD apps. Look at what happened to the senior engineering market. Demand for system architects, infrastructure specialists, and platform engineers is actually holding strong. Why? Because when it costs zero dollars to generate 10,000 lines of code, you don't need fewer engineers. You need better engineers to make sure that mountain of synthetic code doesn't blow up your production server. I told him: "Two years ago, your value was looking up syntax and type. Today, your value is your judgment. Can you break down a messy business problem into concrete technical constraints? Can you look at 5 different architectural patterns an AI suggests and weigh the cloud token costs against technical debt? Can you audit a script and spot the logic flaw before it hits production?"  Laying bricks is cheap now. Designing the building is where the money is. If you are thinking about quitting tech because "AI can code," you are giving up right at the exact moment the boring parts of your job are being automated away. Don't quit. Upgrade your cognitive stack. Move from a coder to a conductor.

If you want to be an AI Engineer, and make TOP dollar in the industry, read this: Here is what the elite 1% of AI Engineers are doing differently: 1. They treat Pydantic as their Data Backbone Models love to output poetic, unpredictable nonsense. Businesses require deterministic, predictable data. Top-earning engineers don't just ask an LLM for JSON; they build strict Pydantic schemas and use structured outputs to force the model’s cognitive leaps into strict data contracts. 2. They build Agentic Brakes, not just Autonomy The engineers making real money are the ones who understand Token Budgeting and Deterministic Fallbacks. When an autonomous agent gets caught in an edge-case reasoning loop, it doesn’t just break the code - it burns through thousands of dollars in API costs in minutes. 3. They master Codebase Intelligence & Context Architecture With the rise of the Model Context Protocol (MCP), the bottleneck isn't the AI's intelligence; it's the context you feed it. Top dollars go to engineers who can build semantic maps of massive enterprise repositories, optimize vector database retrieval (RAG) with advanced re-ranking, and handle complex token context windows without causing latency lag. 4. They focus on Evaluation over Experimentation Junior devs test their AI apps by manually chatting with them 5 times and saying "looks good." Senior AI Engineers build automated evaluation suites using frameworks like LangSmith or DeepEval. They use LLM-as-a-Judge patterns to run automated regression tests on prompts, scoring outputs for hallucination and grounding before a single line hits production.

Your "Local LLM" and “Free AI” dev setup is a massive WASTE of time and money! The hottest trend on X right now is showing off your "local-first" setup. Developers are buying expensive NVIDIA 5090s, bragging about running Llama-3.2 or Phi-3.5 completely offline, and treating cloud API users like absolute peasants. "Look at my zero-latency inference! Look at my data privacy!" It’s a beautiful flex. It's also an engineering Delusion. Here is the truth people are refusing to admit because they want to justify their hardware spending: You are sacrificing massive cognitive reasoning just to say you run on localhost. When you switch your development workflow from a massive, frontier cloud model to a quantized 8B or 7B Small Language Model (SLM) running on your machine, you aren't upgrading. You are downgrading your assistant from a Principal Architect to an intern who drank too much coffee. Yes, SLMs are incredible for hyper-specific, narrow tasks like text classification or basic autocomplete. But for complex system design, edge-case debugging, and cross-repository code auditing? They hallucinate under pressure because they lack the deep parameter weight to handle complex abstraction. Stop trying to turn your local workstation into a miniature data center. Use the frontier cloud models for the heavy intellectual lifting - the system boundaries, the state management, the algorithmic strategy. Use local models for basic syntax completion.

Your $1,200/month cloud bill isn't an infrastructure problem. It's an "AI Architecture" DISASTER! Everyone loves showing off how 5 different background bots are constantly talking to each other, monitoring tasks, and executing code in real-time. It looks beautiful in a terminal demo. It's an ABSOLUTE nightmare when you look at the billing dashboard. If you want to build a bulletproof engineering moat right now, stop focusing on autonomy and start focusing on constraint boundaries: 1. Token Budgeting: Implementing hard caps on how deep an agent can nest its reasoning before forcing a human-in-the-loop fallback. 2. Deterministic Fallbacks: Knowing exactly when to take the problem away from the AI and pass it to a simple, optimized script or a standard PostgreSQL query. 3. State Isolation: Ensuring that if one background bot hallucinates, it doesn't trigger a cascading API chain reaction across your entire cloud network. Velocity without cost efficiency is just an expensive hobby.

The tech layoff data just crossed 100,000 corporate jobs cut in 2026. But STOP calling it a "job shortage." It's an architecture shortage.  The timeline is a bloodbath of doom-scrolling. LinkedIn, Meta, Cisco, and PayPal are slashing workforce headcounts by 5% to 10%, while collectively pouring a staggering $725 billion into AI infrastructure and GPUs this year.  The popular take on X right now is: "AI is replacing developers, payroll is dead, and the junior/mid-level engineering market is permanently cooked." But if you look at what's actually happening behind the scenes on the hiring side, you will realize the popular opinion is completely misreading the room. Companies aren't shrinking their tech teams because they don't need code built. They are shrinking their teams because a single, highly skilled architect equipped with AI can now do the work of a 5-person engineering pod. The era of hiring 10 developers to copy-paste boilerplate, build basic CRUD apps, and manual-test API endpoints is over. The machine does that for pennies. The layoffs aren't targeting technical competence; they are trimming structural bloat. If you look closely at the data, senior individual contributor openings are actually spiking. Leaders like Box CEO Aaron Levie are aggressively hiring for a very specific, new breed of developer: The AI Integration & Platform Engineer.  These aren't prompt-engineering hobbyists. They are the untouchables who understand: 1. System Design at Scale: How to glue multi-agent workflows into legacy corporate databases without causing infinite loops or security leaks. 2. The "Hallucination" Audit: Reading 1,000 lines of AI-generated code and instantly identifying the architectural flaw that will crash under traffic. 3. Business Context: Translating messy product requirements into hard technical constraints that the AI can execute safely. The market isn't rejecting developers. The market is rejecting the old 1x developer playbook. Stop panic-applying to the same generic roles with a resume full of basic API wrappers. Shift your focus to deep system architecture, security guardrails, and algorithmic optimization.

AI Bros on X, you NEED to hear this: If you can build an app in a WEEKEND using a prompt, so can everyone else!! That's not a million dollar app. If your entire value proposition can be replicated by a "Copy-Paste" into a prompt, your profit margins will hit zero faster than you can say "fund me."