How AI Is Changing Software Engineering

I recently talked to our engineering team about AI. Not the hype. What’s actually changing, and why it matters.

Something fundamental is shifting in how we build software. It’s not about writing code faster. The job itself is changing.

It’s Not Just About Code

AI in software engineering isn’t like going from C to Ruby. It’s not a better programming language or a faster compiler.

It’s a shift in abstraction at every level. You don’t just write code faster. You think and work differently.

You spend less time on syntax and more time clarifying what you actually want. Tasks that took a day now take an hour. But the hard part was never the typing. It’s knowing what to build and why.

The job is changing.

Ignore the Hype, Use What Works

AI coding tools have evolved massively in the last two years. LLMs are not magic, but they’re very useful.

Cut through the noise. Try things. Keep what works. Drop what doesn’t.

Most of the hype is garbage. Most of the tools are actually helpful if you ignore the marketing.

Context Coding, Not Vibe Coding

This isn’t about vibes or guessing. It’s about context.

The better your prompt, the better your result. Call it prompt engineering if you want. AI rewards clarity and intent. If you can’t explain what you want clearly, you won’t get it.

If your prompt is vague, the output will be vague. AI is a mirror for your own clarity of thought. This is a feature, not a bug.

Business Context Matters More Than Syntax

The shift is real. Understanding business context, systems, and architecture now matters more than knowing syntax.

Writing code is just one part of the job. Tools are catching up fast on the mechanical parts.

What wins now: creativity, reasoning, system thinking. Focus on the what and why, not just the how. This is why our product manifesto puts problem understanding before solution building.

The Return of the Generalist

Early software was built by small teams. A few people handled everything. Architecture, code, deployment, operations. It worked.

Then the industry specialized. Frontend, backend, DevOps, platform, security, data, mobile. Each domain got deeper. The stack got taller. You needed specialists for everything.

The complexity was real. Building reliable systems at scale required deep expertise in narrow areas.

AI is reversing this. Not because the complexity disappeared. Because one person can now span more of it. A backend engineer can ship decent frontend. A developer can handle infrastructure they’d never touch before. The walls between specializations are coming down.

Specialists won’t disappear. But generalists are viable again.

And here’s what actually matters: as AI handles more implementation, understanding real problems becomes the edge. What does the user actually need? What’s the business impact? How does technology solve this in a way that matters?

These questions were always important. Now they’re most of the job. Same reason our product manifesto starts with problem understanding.

So We’re All Getting Fired

People worry AI will replace engineers. Fair enough. Let’s talk about it.

There’s a massive backlog of work that never got done. Legacy systems running on prayers and duct tape. Business processes still managed in spreadsheets. Small problems nobody could justify automating.

The reason? Cost. A six-month project to modernize an old system rarely made the business case. A custom tool for a niche workflow wasn’t worth the engineering time.

AI changes the math. When building software costs less, more things become worth building. The backlog doesn’t shrink. It grows. Problems that were too expensive to solve become solvable.

This is basic economics. Lower the cost of something useful, demand increases.

The engineers who understand problems and know how to solve them with technology won’t have less to do. They’ll have more. The skill that matters is the same as it’s always been: figure out what’s actually needed and build it.

Embrace Non-Determinism

AI isn’t deterministic. You won’t get the same output twice. This feels wrong if you’re used to predictable systems.

But that’s the point. Deterministic workflows only do what you explicitly program. AI reasons. It adapts. It solves problems you didn’t anticipate.

Combine both. Non-deterministic agents to do things that weren’t possible before. Deterministic building blocks to keep them honest.

Tests. API contracts. Schema validation. Evaluation frameworks. These are your boundaries. AI works freely inside them. The pipeline doesn’t care how the code was written. It validates the output.

Orchestrate this well and you build things neither could accomplish alone.

Learn Early, Share Often

Getting in early and helping others level up with AI gives you (and your team) a lasting edge.

Learn. Understand. Share.

The engineers who figure this out now and teach others will be the ones shaping how we build software for the next decade.

Don’t wait for it to stabilize. It won’t. Get good at working in uncertainty.