Karunjith M

Everybody is after building the next big thing right now. And honestly, I get it. But the frontier labs are going to eat your lunch.

Every new model is exponentially better than the last one, and whatever you build on top of it is stale in a couple of months. We used to say distribution is the moat. But you don’t have a moat when you don’t control the model.

I’ve watched it happen with a lot of YC companies. They pivot, and then pivot again, trying to find something that sticks. The ones with big coffers can afford to be wrong a few times. But how many of the others can? Most of them are just placing a bet and hoping this one is the one. I think a lot of money is going to get burned before anyone figures out what sticks and what doesn’t.

Now, I’m not saying they’re wrong about AI. It is the new interface, and there are going to be a lot of agents. But people still have the purchasing power, and people take time. Look at mobile. It took years before the masses picked it up and made it their own. AI is going to be the same. A couple of years at least.

Because right now, most people are still on the same interfaces they got used to back in 2015. They learned them once, they’re comfortable, and they don’t want anyone asking them to learn something new. They just want their lives to be easy.

And it doesn’t help that AI has a bad rep right now. Most of these companies are going after the enterprise, trying to replace the workforce, and every other week there’s another story about data centers guzzling water.

Then there’s the slop. Comments, posts, even whole pieces of software, generated and thrown out there without anyone reviewing any of it. Even this blog is written with the help of AI, but I read every word before it goes out. Most of what you see out there, nobody even read. And it sticks. Now there are people who hate something the moment they find out it was made with AI.

So everyone says they want human-made stuff now. Then they see what a human charges, and suddenly AI is fine.

Which brings up the basic question. What do people actually want?

Sometimes they know. Sometimes they don’t. And what they say they want isn’t always what they end up picking. But there are always two clear indicators. Price and time. How much it costs, and how long it takes to get something done. That was the whole promise of AI, right? It was going to save us both.

So where is all that?

Building software did get cheap. That part is true. Anyone can put together an app in a matter of minutes now. But the stuff people actually pay for every month still costs the same as it did a few years ago, and some of it costs more, because now there’s an AI tier on top. It doesn’t save them any more time either. It’s the same clicks, the same forms, the same waiting. Somewhere along the way, all those savings just never made it to the people using the software.

That’s the step everyone is skipping. Before chasing what’s next, make the stuff we actually use every day cheaper and easier. You can figure out the next big thing while you’re at it.

And I know what people will say. If anyone can build an app in minutes now, why would anyone pay for one? Where’s the business in that?

See, that’s the part people miss.

Nobody wants to build it. They want to use it. They want to pay less.

Plenty of people have tried building it themselves, and plenty of them burnt their hands. Because it’s not the building part that’s hard. It’s the maintenance. Keeping it running, fixing it when it breaks, updating it when something changes underneath. That’s the tax, and nobody wants to pay it.

This is where AI actually fits right now. Not as a shiny new interface people have to learn, but behind the scenes, making the stuff people already use cheaper and quicker, and taking the maintenance off their hands. Their software should be getting cheaper because of AI, not more expensive.

And it has to be reliable. People need something they can count on, not something that gives them a different answer every time they ask. Get that right first, then ramp up the usage. Slow and steady. Let people evolve to accommodate it.

Because most people don’t care yet. They’re sitting on the fence, waiting to see where this goes. Apart from us software engineers. We seem to be completely hooked.

Opus 5.5 helped me write this blog

People expect more now. Not cost, not speed. Just more. They see what’s possible and suddenly what they already have feels small. So everyone chases. The next product. The next venture. The next million dollar idea.

Meanwhile the stuff that actually works just sits there. The platform that’s been humming along for three years. The dashboard half the company depends on. Reliable, deterministic, boring. It doesn’t get you funding. It doesn’t get you followers. So it rots.

The tools to ship fast are better than they’ve ever been. You have more bandwidth than you’ve ever had. You could take a week, look at your existing systems, and cut your infra bill in half. But you don’t. Because optimizing doesn’t feel like progress. It feels like maintenance. And nobody got into this to do maintenance.

The biggest opportunity right now isn’t building new things. It’s making the old things cost less.

If people actually sat down and optimized what they already have, the cost savings would be massive. Not incremental. But you can’t pitch “we made our existing platform 60% cheaper to operate” to a VC. So nobody does it. Everyone’s so busy chasing what’s next that they let what’s working now fall apart. And when the present breaks, there is no future to chase.

Most companies aren’t high growth rockets burning VC money on purpose. Most companies are small. A million in revenue. Maybe less than ten. Fighting to survive every quarter. For them, cash flow isn’t a metric on a dashboard. It’s whether you make it to next month.

Cash flow is the real differentiator now. Interest rates aren’t going back to zero. The era of cheap money funding sloppy infrastructure is over. What you spend to keep the lights on actually matters again.

And the work isn’t hard. That’s what kills me. The queries that haven’t been touched since someone wrote them three years ago. The services running on instance types nobody bothered to right-size. The cron jobs that fire every minute when they could fire every hour. Most of the waste isn’t hidden. It’s just ignored.

Build the new thing. That should happen in parallel. But for the companies that are actually fighting to survive, the move right now is to make what they already have cheaper, more efficient, more reliable.

Why is nobody obsessed with making things cheaper?

Opus 4.6 helped me write this blog

I collected frameworks like they were proof of something. Flutter, then React, then Spring Boot and Rails made me fullstack, then Python for ETL. Every new thing felt like another brick in the wall. More range, more proof I could figure things out.

Then the wall stopped meaning anything. The application layer I spent years climbing just went flat. So I started going deeper. Into the platform. The stuff underneath the frameworks. How the database engine actually schedules queries. How systems behave when the docs are useless. That felt right. Fewer people down there because fewer people bothered when the application layer was paying well. The knowledge takes years to build. You learn it by getting burned, not by reading tutorials.

And it is the right move. For now.

Platform depth buys you time. It doesn’t buy you safety. AI can already debug better than me in a lot of cases. It can reason about systems, evaluate tradeoffs across tech stacks, make architecture calls I’d need an hour to think through. It’s getting better at this every month. Going deeper just means it takes longer before the ground under you flattens out too.

But here’s what I keep coming back to. AI still can’t sit with a finance team and figure out how to provision infrastructure for a company that’s burning cash and needs to ship in six weeks. It can’t make the call to go managed instead of self-hosted because it talked to the ops team and knows they’re already stretched thin. Those decisions come from context that lives in hallway conversations and Slack threads and years of watching things go wrong in ways that never make it into a postmortem. You have to be in the room for that. You have to have been in the room before.

That’s where I’m trying to go. Not just deeper, but wider. Owning the whole infrastructure. Networking, storage, compute, CI, observability, security. Not expert level in all of them. But enough to make real decisions when the constraints are messy and human. You can’t say “I don’t do databases” anymore. If it touches the system you’re responsible for, it’s yours now.

I’m not comfortable with this yet. I liked having a lane. But the lane is gone and I’d rather adapt than pretend it’s coming back.

The person who was in the room when it broke is the person who gets asked what to do next.

Be the person they call when the constraints are real and the model can’t help. That’s the job now. It always was. We just had the luxury of pretending otherwise.

Opus 4.6 helped me write this blog

The old model was simple. Get exposed to something, take time to understand it, learn the fundamentals, then build.

That still works for a lot of things, but not when AI is writing most of the code. The whole story flipped. You don’t need to understand something fully before you build with it anymore. Just build it, see how it compares against the existing system, see what goes wrong. The failures show you how each piece actually works. You get a map of the system through its fractures.

Build first. Learn from what breaks.

And not just the code. When something breaks you don’t just learn why that function failed. You learn what the product was supposed to do, what the user expected, where the assumption was wrong. Every failure is a window into the system and the thing the system serves.

But building first only gives you the surface. You see the shape of it, not the depth, and you can’t stop there. You take what you skimmed and drill in, layer by layer, with AI running in parallel. One niche at a time. Pick a specific corner and go to the root. AI lets you do that now without waiting for a teacher or a course or a mentor. You just go.

Remove the friction, build as fast as you can, then learn, then build again. Compress that cycle and keep repeating it until you’re comfortable within one specific niche, then pick the next one. Each rotation teaches you the code less and the product more.

This matters because when AI writes the code, you own it. Every decision it made, every tradeoff it picked, every shortcut it took. If you just wave things through without understanding why, eventually something will break and you’ll be staring at a system you can’t reason about. That’s not a hypothetical. That’s Tuesday.

The moment you stop understanding, you stop owning it. Not just the code, but the product, the business logic, the thing users actually touch.

We will lose context of our own codebases. AI will have written most of it, and the repositories will outgrow what any one person can hold in their head.

There’s nothing we can do about that.

The code is temporary. What you understand about the product is not.

The code context fades. The product understanding compounds. What it does, what it doesn’t, where it falls apart, what users actually need. That stays with you. That’s the thing AI can’t take.

Opus 4.6 helped me write this blog

Code was always supposed to solve a problem.

That’s it. Someone has a problem and you write code to fix it. Somewhere along the way we lost that. The code became the thing. Engineers got deep into the craft of it, the clean architecture, the design patterns, the perfect abstraction. And the actual problem drifted. It became someone else’s job to care about.

The people closest to the solution lost sight of what made a solution good. Not the implementation, but the taste. Knowing what’s worth building and what isn’t.

So we built layers to compensate. Product managers to translate business problems into specs, engineering managers to keep teams aligned, program managers to keep the managers aligned. A whole chain of humans existed because the people writing the code had drifted so far from the problem that you needed bridges to connect them back.

Taste got distributed across a dozen roles, and nobody owned it fully.

The code was never the point. The problem was. And taste was knowing the difference.

That worked for all these years. It was inefficient but it worked. Everyone had a role and everyone had a seat.

All the code we wrote, every design pattern, every architecture doc, every refactor, every Stack Overflow answer, every pull request we agonized over. That’s what trained the AI. We built the dataset. Years of collective engineering effort poured into the machine that’s now replacing the need for most of it. We spent decades perfecting the craft of writing code, and that craft became the training data for a system that makes the craft optional.

Now AI walks in and blows up the middle.

AI is removing the implementation bottleneck, and when you do that, the distance between the problem and the solution shrinks. You don’t need three layers of translation anymore. An engineer who understands the business problem can go straight to a working solution. The gap that justified all those middle layers is closing.

The org chart that made sense when implementation was slow and expensive doesn’t make sense when it’s fast and cheap. That’s what’s behind a lot of the layoffs we’re seeing. Not just cost cutting, but structural.

Who thrives in this? The people who were always a little too self-directed for the old system. The ones who cared about the problem, not just the ticket. Engineers who think like owners, designers who ship working prototypes instead of Figma files, product people who understand what’s buildable.

People with taste. People who can look at what AI hands them and know whether it’s right. Not whether it runs, but whether it’s right.

Specialization was the path for all these years. Stay in your lane, write the code, let someone else worry about whether it’s the right code. That comfort is gone now. You need to think a level above your pay grade, maybe two or three levels above. And as AI keeps improving, that number only goes up.

AI lowered the entry barrier so anyone can build now, but it raised the ceiling massively. The tools are the same for everyone, same models, same access, same starting line. What separates people isn’t what they can build, it’s whether they know what’s worth building.

You are the user. Every product, every feature, every interaction is for a person on the other end, and you are one. You know when something is off before you can explain why. You know when a flow is annoying even if it technically works. AI can generate solutions all day, but it can’t feel what it’s like to sit on the other side of them.

The judgment to know what’s worth making, the instinct to kill a feature that works but doesn’t matter, the refusal to ship something that’s fine but not good. AI doesn’t have any of that.

Taste is all you have. Not effort, not speed. The willingness to look at what the tool hands you and say no, that’s not it. That’s the job now.

Opus 4.6 helped me write this blog

I haven’t slept properly in two days.

Not because something is broken. The opposite, actually. Everything works, and that’s the problem.

I’ve been using Claude Code for over three months now. It was fine at first, productive and useful and controlled. But this past week something shifted. It became a loop. Build something, deploy it, see what could be better, refine it, deploy again. Two days of this with barely any real sleep. I’d lie in bed and my brain just wouldn’t stop running through what needed restructuring, what deploy could be cleaner. I’d fall asleep for a couple of hours, wake up mid-thought already planning the next change. I was dreaming about Claude Code, actual dreams, and then waking up from those dreams and reaching for the laptop.

Close the lid. Sleep for a bit. Open the lid. Repeat.

The old bottlenecks used to save you from this. Typing speed, debugging, waiting for a build. Implementation itself was the wall, and hitting it gave you a natural place to stop. Those walls are gone now. The tool is capable enough that the bottleneck is never the tool, it’s always you. Your ideas, your stamina, your willingness to keep going. Most of the time I’m not even typing code, I’m rambling into audio mode, talking through ideas like I’m explaining them to someone. And it just works.

But nothing comes free.

You’d think being more productive would feel good, and it does at first. But then something breaks. Before AI, the hard part was implementation. You’d spend hours just getting something to work, and when it finally did, that was the win. Now implementation takes minutes, so you skip straight past the win and into the details. Refining, tweaking, polishing, and then refining the refinement. The bar moves every time you reach it. There’s no moment where it feels done, because you know you could make it better and now you actually can. The satisfaction that used to come from building something is gone, replaced by an endless loop of “but what about this part.”

That’s the thing nobody talks about. The friction was the finish line. When building was hard, finishing meant something. You hit the wall, you pushed through, and the act of getting it to work at all was enough to call it done. Remove the friction and there’s no signal to stop. You just keep going, refining past the point of usefulness, losing sleep over margins that don’t matter.

The tool doesn’t get tired. You do. And there’s no version of you that can keep up with a machine that never needs to stop. You’ll try, you’ll lose sleep trying, and then you’ll realize the only skill that matters now is knowing when to close the lid and mean it.

Let’s see.

Opus 4.6 helped me write this blog