In the ~25 years I’ve been writing software, I’ve never been so excited (and terrified!) by what is happening in technology. It seems like we’re living through a watershed moment. Not one that’s coming: one that has actually already occurred, with most of the industry still grappling to understand the implications. And that’s for one simple reason:

The assumptions that governed this profession no longer hold

For most of my career, software development was organized around a simple truth: that developer time is the single most constrained resource within a company whose product or service is software.

That one fact can singlehandedly explain a remarkable amount of the process, organizational design, and ways of working that still governs much of this industry. It explained the religion behind many project management methodologies, both lightweight and heavy. It explained rapid headcount growth, offshoring, and the search for lower-cost development labor. It explained long planning cycles, granular work decomposition, specialized handoffs, elaborate estimation rituals, and management systems built to coordinate around scarce implementers.

That model made sense when the production of high quality code was the bottleneck. If the scarcest thing in the company was developer time, then of course you built process, planning, staffing, and management systems around preserving and directing it. Of course you obsessed over prioritization, sequencing, estimation, decomposition, and handoffs. Of course you treated implementation capacity as the limiting reagent in the whole machine.

We no longer live in that world. The bottleneck has moved away from implementation capacity and toward coordination, judgment, and verification. That shift has consequences not just for how teams build, but for how they organize, what they optimize for, and where defensibility now comes from.

Here are eleven new truths, born out of assumptions that no longer hold:

1. It is now cheaper to try things than to align on them

A proof of concept can often be created before the meeting even makes it onto the calendar. Coordination is now more expensive than experimentation. Meetings are not the work. They arguably never were, but now that coordination costs more than execution, the drag of heavyweight process is impossible to ignore.

2. The economics of technical debt have inverted

The assumption that you’re stuck with your legacy stack or your tech debt was really an assumption about rewrite cost. “Never rewrite” was Joel Spolsky’s famous advice, and it was sound when rewriting meant years of parallel effort with high risk. A full rewrite or replatforming is now possible, in days. That doesn’t mean every legacy system should be rewritten, but the option value of rewriting is much higher than it used to be. “We’re stuck with it” becomes a choice, not a constraint.

3. More people is no longer a clean answer to more output

Brooks’s Law already warned us that adding people to software work can make it slower, not faster. But as implementation gets cheaper, the coordination side becomes even more visible. Combinatorial explosion takes over. More people means more interfaces, more dependencies, more handoffs, more communication paths, and more chances for delay or confusion. The additional capacity is real. The drag is too. Increasingly, the drag wins.

4. The boundaries between PDLC roles have collapsed

AI expands the effective range of every role across the Product Development Lifecycle (PDLC). Product can prototype. Designers can generate working flows. Engineers can write specs, tests, and operational scaffolding. QA and SRE concerns can shape the work much earlier and much more directly. The result is not just more productive individuals. It is a different team shape: more senior, less specialized, more end-to-end, and more autonomous. Companies that still require high levels of cross-team coordination or heavy management oversight will be on the wrong side of this shift.

5. Product ideation is no longer exclusively human

Once AI sits at the center of the PDLC, it can do more than just help build what people have already conceived of. It can generate concepts, write specifications, produce variants, and pressure-test them against each other to find winners, using experimentation at scale to turn qualitative hunches into quantitative signals. The human role moves up a level: less authorship, more judgment. Less drafting, more choosing. The bottleneck is no longer ideation, it’s discernment.

6. Clarity is now a core engineering skill

Clear writing and clear thinking are no longer soft skills adjacent to engineering, expected only of principal engineers and the leader class. They are now central to software engineering. Humans build better from clear intent, and machines do too. A strong specification doesn’t just communicate what to build, it constrains interpretation, sharpens decisions, exposes contradictions early, and makes verification easier. In a world where more output can be generated quickly, the quality of the input matters even more.

7. Verification is no longer a support function, it is the work

When instructing AI, good tests are not engineering vegetables. They are water. TDD and BDD are no longer nice-to-haves. They are critical both to steering LLMs toward correct output and to verifying that the output is actually correct.

8. Business leverage matters more than technical elegance

The most valuable engineering work has always been the work that solves business problems, not just technical ones. But when implementation was expensive, technical skill was the bottleneck, so it was natural to optimize for it, celebrate it, and build culture around it. That made sense. Now that building is much cheaper, the premium shifts. The engineer who can identify the highest-leverage problem to solve is more valuable than the one who can solve a given problem most elegantly. Taste, commercial awareness, and product instinct are no longer optional enrichments to a technical career. They are the difference between output and impact.

9. Humans are no longer the only users of your product

As agents become a real source of traffic and execution, the center of gravity shifts from human-facing UX toward machine interfaces as well. That does not mean UX stops mattering. It means it stops being the only front door. Clean APIs (incl. MCP), permission models, schemas, and reliability become product features, not backend hygiene. Agents will follow the path of least resistance. In that world, APIs stop being integration surfaces and start being distribution surfaces.

10. The software engineering apprenticeship ladder is under threat

For years, we trained up engineers by giving them bounded implementation work: small tickets, straightforward endpoints, boilerplate, test fixes, and low-risk bugs. This work was never glamorous, but it was how people learned codebases, delivery, and the reality that software engineering is not about the happy path – it’s about everything else around it. AI will compress a great deal of it. That does not mean junior talent stops mattering. It means the old apprenticeship model does. Our industry will need new ways to develop judgment, taste, and end-to-end understanding, because the work that used to train people is the work that AI compresses first.

11. There is no such thing as a pure software moat anymore

The implications of this one are massive: a lot of software moats were never really durable moats, they were implementation-cost moats. They looked durable only because building the thing was hard. Once building gets cheap, that kind of moat starts to evaporate. The defensibility does not disappear, but it moves away from code itself and toward the system around it: distribution, data, trust, workflow entrenchment, network effects, and operational excellence.

---

This is why I am both excited and terrified. Excited, because small, sharp, autonomous teams are about to become capable of absurd amounts of leverage. That has always been my preferred way to work. Before AI, there were still hard limits to what even the best small teams could accomplish. Those limits are breaking.

I am terrified because I am fully confident the list above is incomplete, and that in six months parts of this post will already feel dated. The ground is still moving. We are all going to have to reinvent ourselves, and then do it again.

In the meantime, teams that are AI-native in their PDLC will run laps around teams that are still struggling to absorb the implications or choose to view it only as a simple enabler instead of embracing what it really is: a wholesale shift in how software gets built.

---

Big thanks to Kasey Klipsch for always being a great sounding board on many software development and management concepts over the last decade.