Let’s start with an assumption:
In five years, 90% of code will be written by AI.
That doesn’t mean software engineers disappear. It means the job evolves — fast.
It’s never been just about the code. And, going forward, it will be even less about code, and more about what surrounds it:
- Domain expertise; understanding what should be built and why
- Deeply understanding business needs and turning them into technical requirements that AI can execute
- Designing systems that are resilient, testable, and maintainable
- Creating amazing test suites and understanding their output
The engineer becomes an orchestrator:
Not of people, necessarily — but of AI agents, automated pipelines, and domain complexity.
What matters is not how fast you can code, but how well you:
- Guide AI to build the right thing
- Spot flaws in logic, alignment, or infrastructure
- Shift between greenfield and brownfield development without slowing down
Being an orchestrator means setting many things in motion at once — sometimes literally running tools in parallel, but more importantly ensuring that each piece, each “instrument,” plays in harmony with the others. A test suite here, an AI code generator there, a refactoring pipeline over on the side — all with their own internal expertise. The engineer’s role is to make sure they’re all playing the same piece with the same feel.
This is more than a continuation of past shifts (like the rise of DevOps). For new engineers especially, it’s a fundamental change: you won’t spend your early career writing millions of lines of code by hand. You’ll spend it orchestrating millions of lines written by AI. That means you’ll log your 10,000 hours in orchestration, not in pure coding. Think of it like the difference between milling your own lumber versus buying it from the store: both can build a house, but the skills and resources required are different. This shift will sometimes clash with the expectations of senior engineers who still think a sorting algorithm whiteboard test proves capability.
Greenfield will feel like brownfield:
Anyone who’s started a new job where there’s an existing codebase knows the feeling:
It works, but the code feels alien — because you didn’t craft it line by line.
That’s brownfield, and it’s the future. AI takes your suggestions (vibes?) and writes code that you may only glance over or run through a test suite.
You’ll be expected to:
- Ramp up quickly on unfamiliar, AI-generated codebases
- Dive deep to fix performance issues or production bugs
- Untangle complicated, “correct sounding”, (but bad) decisions made by an AI
Even when you start a brand-new project, it won’t feel greenfield in the old sense. You may design the architecture, but you won’t write every line of code — AI will. And that lack of intimacy changes your relationship with the system.
Think of it like being in a cover band: you can perform the songs and even make them sound great, but you weren’t the one who sweated over writing every note. What used to feel like pure creation now feels like adaptation — greenfield that behaves like brownfield.
To thrive here, you’ll need new habits. You’ll have to ramp up quickly on code you didn’t write, spotting patterns in what AI produces and judging whether they’re sound. Debugging shifts from knowing every detail to being precise about expectations versus results — keeping the good parts intact while fixing the broken ones.
Patterns will be a better guide than syntax. Recognizing the architecture and design intentions behind the code will serve you better than memorizing language quirks. Requirements and expected outputs become your compass. And because AI can touch every file in a repo with a single edit, you’ll need to think globally: what changed, and how you prove it’s still working as intended.
The skills that matter more:
- Architecture thinking: scale, resilience, changeability
- DevOps + platform understanding: building your product on the right foundation
- Testing and verification: AI can write tests, but you decide what matters
- Domain fluency: especially in fast-moving or regulated industries
- Communication: across teams and with the AI itself
- Business acumen: yes, you need to know what’s going to fly or flop
Of these, two areas I’ve seen consistently undervalued by engineers: domain/business acumen and testing at scale.
Domain knowledge isn’t optional anymore. If you’re working in a specialized domain like ad tech, fintech, or health, you need to understand the rules of that world. You won’t arrive with expertise, but you should show up ready to learn. Take salespeople to lunch, shadow PMs, ask executives what books they read or which podcasts they listen to. Then follow through — listen weekly, read monthly, and yes, even invest in yourself by going to a conference a year. Don’t wait for your company to pay for it. Bring that knowledge back, share it with your team, and you’ll start being seen as an expert.
Testing, meanwhile, isn’t just unit tests. It’s whole-system thinking. In an AI-driven world, one small request can edit every file in an entire repo. Agile workflows have trained engineers to handle bite-sized tickets, but AI-generated code will demand broader coverage. You need to design test suites that validate entire systems even across unfamiliar codebases.
How to practice these? Build complete projects yourself — end to end. Contribute to open-source systems that have been around for years, because those are the real brownfield playgrounds. You’ll get the feedback from passionate peers, see complex systems at work, understand user demands, and get something cool to add to your resume.
For engineers starting their careers now:
This isn’t about learning to code; it’s about owning outcomes and operating at a higher level — directing, debugging, and validating expansive systems.
Focus on:
- Software design principles
- Domain expertise; learn how to learn
- Rapid problem-solving
- Prompting with clarity
- Understanding unfamiliar code
- Communicating across tech/product/business lines
On day one, bring the right mindset to dive deep. Work is play — or it should be. If you approach your career as a box-checking exercise, you’ll stagnate. If you immerse yourself, the office becomes a playground of ideas and systems to explore. Forget the free snacks; the real perk is that you get to spend your day building — and owning — things you’re passionate about.
In short:
Coding won’t disappear. But your role will shift — from creator to conductor.
Those who embrace this shift early will have an edge.
And the single takeaway? Be prepared to be an owner. You’re not just a worker on a small piece — you own the system: its quality, its design, its product context, and its place in the world.
That mindset — ownership, immersion, and orchestration — is the real playbook for the AI era.