We are now a few good years into the AI wave. Copilot, then ChatGPT, then agents everywhere. Each wave arrived with the same announcement, everything you know is obsolete. I heard that announcement many times over the years, so this time I decided to keep a quiet list. Not of what changed. Of what did not.
This post is that list. It is short, it is boring, and I think it is the most valuable thing I can write right now. Because I work at an investment firm these days, and one lesson from that world transferred perfectly to ours. The exciting bets make stories. The boring fundamentals make returns.
Abstraction still decides everything
Barbara Liskov taught us that the heart of programming is abstraction. A module promises something, hides how it does it, and the rest of the system depends on the promise, not the insides. Get the promises right and the system stays changeable. Get them wrong and every change touches everything.
Four years of AI did not move this one centimeter. If anything, it raised the stakes. Agents generate code inside whatever boundaries you give them. Give them clean modules with clear contracts and they produce code that fits. Give them a mud ball and they produce more mud, faster than any human ever could. The machine respects your abstractions exactly as much as they deserve.
I review generated code every week, and the failures are almost never syntax. They are promise failures. A function that does a little more than its name says. A module that quietly reaches into another one. The skill of seeing those problems, the skill Liskov described decades ago, is the review skill of 2026.
Measure before you optimize
Knuth warned us that premature optimization is the root of all evil, and people quote it so much that they forget to obey it. The full lesson was never “ignore performance.” It was “measure first, because your intuition about where the time goes is usually wrong.”
This survived the AI wave completely intact, and it grew a new application. Today people optimize prompts, swap models, tune agent setups, all by feeling. Same old mistake with new toys. The teams getting real value are the ones that measure. How long did this task take before and after. How many review cycles. How many defects escaped. Boring numbers, written down. Without them you are not engineering, you are collecting anecdotes.
Money hides in this discipline. I have seen teams pay for tooling that solved a problem they never measured, and sometimes a problem they did not even have. The slow part of their delivery was approvals, not code, but they bought a faster compiler anyway. A measurement habit costs almost nothing and protects the budget like a guard dog. It stops you from spending real money to fix an imaginary bottleneck.
Messages and boundaries
Alan Kay always said that the big idea of objects was not the objects, it was the messages. Systems built from parts that communicate through clear messages, where the parts can change without breaking the conversation.
Look at anything good built with AI today and you find this idea wearing new clothes. Tools talking to models through defined interfaces, agents calling services through contracts, MCP and friends. The whole modern stack is a lesson in boundaries and messages. The people who understood Kay decades ago looked at this new world and felt at home. The fundamentals did not just survive, they became the architecture.
For a team, boundaries are also a risk story. A clear boundary is the line where you can stop a failure, replace a vendor, or swap a model when a better one ships. Every boundary you design well today is an option you hold for free tomorrow. Investors pay real money for options. Architects get them by thinking clearly.
Small steps
Kent Beck built a career on a humble idea. Take small steps, keep the tests green, integrate often, learn as you go. He still writes about it, now in the middle of the same AI storm as the rest of us.
Small steps matter more with agents, not less. The temptation today is the giant step, ask the agent for the whole feature, get two thousand lines, merge and hope. I tried it, everyone tried it. The review is impossible, the bugs hide in the volume, and when something breaks you cannot tell which of the fifty decisions was wrong. Small steps with verification after each one is how you stay in control of a very fast horse. The horse got faster, so the harness matters more. And no, I do not mean the famous tool that borrowed the name. I mean the real harness, the small verified steps that keep the fast animal from running you into a wall.
Boring wins, in code and in money
Here is the pattern under all four names. Liskov, Knuth, Kay, Beck. None of these ideas is exciting. No keynote ever went viral about measuring before optimizing. And yet every one of them paid out through every wave I lived. Object orientation, the web, mobile, cloud, microservices, and now AI. The tools on my desk in 2006, back in my company days in Brazil, are all dead. The ideas in this post outlived every one of them.
That is the definition of a good long term investment. Low drama, compounding returns, survives the crashes. Fundamentals are index funds for a career. The hot new tool is a single stock, sometimes it pays, often it does not, and you cannot tell which in advance.
So my advice for a developer planning where to spend learning hours this year is the same advice a boring financial planner would give. Put most of it in the fundamentals. Learn abstraction deeply, learn to measure, learn boundaries, learn to move in small verified steps. Spend a smaller part on the tools of the season, enough to use them well. The tools will change again, that is the one safe prediction I will make. What did not change in four loud years is probably what will not change in the next ten quiet ones.
Pax et bonum.