· 7 min read
Product engineers will run early stage startups
I've been thinking about this a lot lately. The way we build software is changing so damn fast that job titles from two years ago already feel outdated, and if I had to bet on one role that's gonna dominate early stage startups in the next five years, it's the product engineer.
Traditional software teams had a very clear division na. Designers made things look good, frontend engineers built the UI, backend folks handled server stuff and product managers decided what to build, and everyone stayed in their lane. It worked I guess, but god it was slow. Every handoff was a potential bottleneck, and if someone misunderstood something you'd lose two weeks.
Early stage startups, and even Series A and B companies, don't have that luxury because they can't afford to wait. They need people who can think about what to build and also build it, someone who gets users, can design decent interfaces, writes code that works and ships fast. That's basically what a product engineer is, a generalist who can switch hats without making a mess of things.
Now throw AI into this and it gets wild. The biggest shift I've noticed is that you don't need to remember syntax anymore. I genuinely can't remember the last time I googled how to center a div or looked up the useEffect cleanup syntax, and that stuff doesn't really matter now as long as you know you need a cleanup function in the first place.
So the skill now is first principles thinking, breaking problems down from scratch and working out what you're actually solving, what the simplest approach is, what tradeoffs you're making, how data should flow through the thing and where the logic even belongs. These are architecture questions, system design stuff, and no AI can answer them for you because they need context about your users, your constraints and your weird business requirements that don't make sense to anyone outside.
Once you've figured that part out though, the actual coding becomes almost trivial. You tell Claude or Cursor something like "I need a webhook that listens for this event, validates the payload, updates the database and triggers a notification", and it writes the syntax, boilerplate and error handling for you.
I was a frontend engineer for years, doing React, TypeScript and vanilla CSS. I could build complex layouts, animations and component systems from scratch, and I spent hours perfecting stuff. But for the last seven or eight months I haven't written a single line of UI code myself, everything's been AI generated with Cursor, Claude, v0 or whatever works. I still shipped seven projects in four months, and they look good too. QuietInbox got featured on dev.to, Vortex went viral and RoomcraftAI has actual paying users.
That works because the skill moved from writing CSS to knowing what good looks like. It's having taste, understanding what users actually need and being able to explain that clearly to an AI. The code part is getting commoditized real fast, but the thinking part is still on us.
Earlier you needed two things to build software, knowing what to build and knowing how to build it. The how part took years of learning frameworks, memorizing APIs and understanding all the quirks of whatever language you were using. That was the moat, and it's what made senior engineers worth their salary.
Now AI does most of the how, so the moat shifted. What matters now is whether you can think clearly, design systems that won't fall apart at scale, make good product calls and architect something that actually makes sense.
Design engineers are having a moment too btw. They were always this weird hybrid somewhere in the middle between designer and engineer, and companies never really knew what to do with them honestly. Now they're super valuable because they have taste plus technical understanding, and AI tools desperately need that from humans.
AI generates code, and sometimes pretty good code. But it can't tell you if something feels off, it won't notice that the spacing looks weird or the interaction is clunky, and it can't make product decisions or prioritize. It can't look at your system and go "yeah this is gonna be a problem in six months".
The way I work now is completely different from two years ago. Most of my time goes into thinking, sketching data models on paper, drawing system diagrams and figuring out how pieces talk to each other. I'm working out what happens when this thing fails, whether we should cache something, and whether it should be a separate service or stay in the monolith.
When I actually sit down to "code" it's mostly prompting. I describe what I want, review what comes back, ask for changes and iterate. Sometimes I tweak things manually but that's becoming rare honestly.
I think early stage teams are gonna be small groups of product engineers who can do everything reasonably well instead of one thing perfectly. AI handles the boring stuff like boilerplate, bug fixes and UI components, and humans focus on what AI can't touch, like talking to users, making product calls, understanding the market, designing systems and iterating on real feedback.
A ten person engineering team becomes three people shipping the same amount. The designer who only designed now also implements, and the frontend dev who only wrote React starts thinking about the whole product.
This is already happening tbh. Look at the teams building interesting stuff right now and they're tiny, two or three people, sometimes one person building things that would've needed whole departments before.
If you're starting out or thinking about what to learn, my honest advice is don't spend ages memorizing syntax or learning every detail of a specific framework, because that knowledge expires fast now. Focus on fundamentals instead, like how databases actually work, how the web works, what makes an API design good or bad, how to think about system architecture and how to break complex things into smaller problems.
You still need a foundation though, ignoring the basics completely would be dumb. Understand what a promise is before architecting async flows, know what SQL joins do before designing data models, and write some code manually so you know what questions to even ask the AI.
But don't get stuck there for months. I've seen people try to master every React hook or memorize CSS properties before building anything real, and that's the wrong approach now. Learn enough to start and figure out the gaps as you go, because when you hit something you don't know, AI helps you fill it in minutes instead of days.
The old way was to learn everything and then build. The new way is to start building, learn along the way and let AI cover what you don't know yet. You don't need permission to build anymore or need to wait till you're "ready". You'll never feel ready anyway, so start and you'll figure it out.
I learned more backend architecture in two years of actually shipping stuff than in years of tutorials and courses, because building real things means hitting real problems and you learn fast when you have to solve them.
Learn enough frontend to be dangerous, enough backend to ship and enough design to have taste. Most importantly, learn to think from first principles and communicate that thinking clearly, because that's what you'll be doing most of the time while AI handles the rest.
The title might change since the role is still evolving, but I think companies that get this early will move way faster than everyone else, and people who position themselves as product engineers instead of just engineers or just designers are gonna be in demand.
Used LLMs to correct grammar and typos.