So you vibe-coded another app over the weekend. It works on your machine. It has a login screen, a database, a few clever features, maybe even a decent design.

Congratulations.

I mean that only half sarcastically. It is fun. I do it too. Building small things with agents feels different from the old way of building small things. The distance between an idea and something you can click has collapsed. Sometimes the result is better than what I would have built myself in the same amount of time, without AI.

But I am getting tired of the same story being told as if it proves something important about software engineering.

For a profession that likes to take itself seriously, we should be more careful about what we celebrate. The number of tokens your team burned is not a success metric. The number of lines of code produced with those tokens is not a success metric either. If anything, it should make us nervous.

Code is still a liability.

That did not change because an AI wrote it. Someone still has to understand it. Someone still has to run it, debug it, secure it, migrate it, explain it, and eventually delete it. The old rule still applies: the less code you own and maintain, the easier your job becomes.

We create software to solve business problems. The smallest solution that actually solves the problem is usually the best solution. This was true before AI. I don’t see why it would suddenly stop being true now.

What changes is the temptation.

When code becomes cheaper to produce, we produce more of it. A helper script becomes a service. A service becomes a product. A product grows a dashboard, permissions, notifications, settings, integrations. It all feels cheap at the moment of creation. The bill comes later.

Other professions understand this better than we do.

If you use twice as much concrete in a building, the building does not automatically become twice as stable. It matters where the concrete goes. It matters what load it carries. There are places where more concrete helps. There are places where it is waste. And if you put too much weight in the wrong place, you can make the building worse.

Software has the same problem, but we are much worse at measuring it.

We talk about complexity, but mostly as a feeling. This codebase feels messy. This architecture feels clean. This team moves slowly. That team somehow keeps shipping. We have metrics for many tiny things, but very few useful ways to compare the complexity of a codebase with the complexity of the business problem it is supposed to solve.

I think this is where AI could become genuinely useful.

Not by writing more production code. The more interesting question is whether it can help us understand the systems we already own.

Can it help us find the parts of the codebase that carry too much weight? Can it generate small reproduction cases for bugs that usually take hours to isolate? Can it build better test scaffolding around risky areas? Can it explain why a change is slow, where coupling has grown, which abstractions are no longer paying for themselves?

This kind of work used to be expensive. Not because it was unimportant, but because nobody had time for it. Teams were already busy building the product. Investing deeply into system understanding often felt like a luxury.

That may be the real opening.

If AI gives us more engineering capacity, spending all of it on more production code feels like the least imaginative option. Production code is the hardest place to start. It is where the stakes are highest, the context is messiest, and the cost of a subtle mistake is real.

There is plenty of code around production code that is easier and safer to automate first: tests, diagnostics, migration checks, performance measurements, debugging tools, complexity reports, throwaway scripts that help you understand what is actually happening.

That work is less glamorous than shipping another weekend app. It does not make for a good screenshot. But it might matter more.

The serious use of AI in engineering may not be writing more code. It may be finally understanding the code we already own.

I really don’t know why we are laughing in this picture.

We founded hackers&wizards GmbH on March 31st. The letter we are holding arrived late June. Almost three months for our Steuernummer.

In those three months, we had to send out the first invoices anyway. Clients don’t wait. So we sent them without a Steuernummer. Some came back rejected. We had to redo all of them once the letter finally arrived. That is a lot of rework that exists for no good reason.

The process gives you nothing to hold on to. No SLA. No estimated timeline. No confirmation that anything is moving. Everyone warns you it could take long. Nobody tells you how long, because nobody knows. You just wait and send invoices into the void.

There is a proposal on the table — the EU Inc — a simplified company structure that would let founders across Europe get started without this kind of friction. I hope it gains momentum fast.

But for now: we have our Steuernummer. And we have invoices to send. Thanks to all our customers for going through this patiently with us.

After 20 years on iOS, I recently switched to Android. I expected to miss iMessage, or the animations, or one of the many apps I learned to love during the years. The app I actually miss most is Apple Maps.

Not because it navigates me better than Google Maps. It often doesn’t. What Apple Maps does differently is harder to pin down. It’s calmer. The interface is quieter, less cluttered. But it goes deeper than visuals. Apple Maps doesn’t reroute you every 90 seconds to save 30 seconds of driving time. It picks routes that are pleasant to drive. Wider roads, fewer complicated turns, the scenic option when the time difference is negligible. It optimizes for a relaxed driving experience, not for shaving off every last minute.

Google Maps, by contrast, is relentless. It will send you through a residential neighborhood and three awkward left turns to save you one minute. It’s technically correct. It’s also stressful. The two apps solve the same problem with very different attitudes.

That difference is personality.

Software has always had personality, even before AI. Apple’s entire business is built on it. But most of the time, we talked about it in terms of design or UX. A nicer font, a smoother animation, a more intuitive layout. Personality was a surface-level quality.

With AI-powered tools, personality goes much deeper. It’s no longer just how something looks — it’s how something thinks, responds, and collaborates with you.

I notice this every day with Claude Code. It’s easy to drive. When I work with it, there’s a natural back-and-forth that feels comfortable. It doesn’t fight me. It doesn’t overwhelm me with options. It has opinions but holds them loosely. Working with Claude Code feels like pairing with someone who has good instincts and knows when to step back.

Codex, interestingly, went through a personality shift. Until a few weeks ago, it was dull to use. Technically capable, but joyless. Like driving a rental car that does everything fine but has no character. Recently, something changed. It became more engaging, more fun to work with. Same underlying capability, but the experience of using it shifted noticeably.

Then there are tools like GitHub Copilot or Kiro. They work. They’re useful. But if you asked me what their personality is, I’d struggle to answer. They feel like utilities — functional, competent, forgettable. No strong opinion about how things should be done, no distinct voice. They get the job done the way a microwave heats food: reliably, without leaving an impression.

This matters more now than it used to. When software was static — buttons, forms, workflows — personality was a nice-to-have. A well-designed app was more pleasant to use, but the core interaction didn’t change. You clicked the same buttons either way.

AI tools are different. They’re conversational. They make decisions. They have preferences, even if those preferences are just statistical tendencies. The software feels alive in a way that a settings dialog never did. And when something feels alive, personality becomes the thing that determines whether you want to spend time with it.

I think the companies that understand this will pull ahead. Not because their models are smarter — the capability gap between the top models is narrowing. But because their products feel like something. Apple understood this decades ago with hardware and software. Now the same principle applies to AI products.

The best software has always had a point of view. Now it just matters a lot more.

There’s a story going around right now that goes something like this: AI makes us so efficient that we’ll soon have more free time than we know what to do with. We’ll work four-hour days, take Fridays off, pick up hobbies, learn instruments. We become time millionaires — rich in hours, finally free from the grind.

It’s a nice story. I don’t think it’s what’s going to happen.

In 1865, the economist William Stanley Jevons noticed something counterintuitive. James Watt’s steam engine had made coal dramatically more efficient. A given task required far less coal than before. You’d expect coal consumption to drop. Instead, it soared. Cheaper energy per unit meant people found entirely new uses for it. Industries that couldn’t justify coal before suddenly could. Factories spread. Railroads expanded. Efficiency didn’t reduce demand — it unlocked it.

This is known as Jevons paradox, and it keeps showing up everywhere.

More fuel-efficient cars didn’t reduce total miles driven. People just drove more — longer commutes became tolerable, road trips got cheaper, households added a second car. The savings per mile got spent on more miles.

Or take laundry. Washing machines became dramatically more efficient over the decades — faster, cheaper to run, easier to use. Did people do the same amount of laundry in less time and enjoy the free hours? No. They raised their standards. Shirts that used to be worn three or four times before washing now go in the hamper after one wear. We wash towels, sheets, and gym clothes at a frequency our grandparents would find absurd. The machines got better, and we just did a lot more laundry.

Every time we make a resource cheaper to use, we use more of it.

I think we’re watching this happen to software right now.

Agentic engineering has made writing code dramatically cheaper. A feature that took a day takes an hour. A prototype that took a week ships in an afternoon. The cost per unit of software has dropped through the floor.

And the response hasn’t been “great, now we need fewer engineers.” The response has been “great, now we can build more things.” Projects that were too small to justify get started. Side features that sat in the backlog for months get built in a day. Internal tools that nobody would have staffed a team for suddenly exist.

I see this in my own work. I don’t write less code than I did a year ago. I write significantly more. The bar for “worth building” has dropped. Ideas that I would have filed away as “nice to have, maybe someday” — I just build them now. The tool I wrote this week to generate banner images for my newsletter? A year ago, that would have stayed on a sticky note. Now it exists, it works, and it took an afternoon.

The same thing is happening at companies. Teams aren’t shrinking. Backlogs aren’t getting shorter. Instead, the definition of what’s worth building is expanding. More experiments, more internal tools, more automation, more custom solutions for problems that were previously solved with spreadsheets and manual processes.

Jevons would have predicted exactly this. When the cost of producing something drops, you don’t produce the same amount more cheaply. You produce more. The efficiency gains get absorbed by increased demand.

This has implications for the time millionaire fantasy. If you’re thinking about AI as a way to do the same work in less time and then go home early, history suggests otherwise. The more likely outcome is the same people doing a lot more work. The bottleneck shifts from execution to deciding what to build — and then to maintaining everything you’ve built.

We’re not going to become time millionaires. We’re going to become people who build, create, and produce at a pace that would have seemed impossible a few years ago. Whether that’s a better outcome depends on how well we manage the abundance — and whether we’re intentional about protecting the time that actually matters.

My newsletter started out covering 3D printing in 2024. I moved on to other topics, but a story on The Verge pulled me right back.

Across the US, a loose network of about 40 people with 3D printers has shipped over 200,000 whistles to 48 states. Communities use them to alert neighbors when ICE agents are nearby. The cost to print one: roughly two cents.

One of the makers, Kaleb Lutterman in Minneapolis, prints on a Bambu Labs P1S. Exactly the same machine, that I own. I’m just happy there’s no need for these whistles here. He fits 100 whistles on a single plate, runs a batch in about seven and a half hours, and gets 800 whistles out of $15 worth of filament. Most of the people involved don’t know each other’s real names. They coordinate loosely and ship for free.

Whatever your stance on the politics, the technology angle is hard to ignore. A few hundred dollars’ worth of equipment in someone’s living room can produce functional objects at scale, overnight, for nearly nothing. No factory, no supply chain, no lead time. Hard to shut down.

When I was writing about 3D printing two years ago, I was mostly thinking about replacement parts, household gadgets, and fidget spinners. I didn’t expect it to show up in this context. But the same properties apply: it’s fast, it’s cheap, and it’s decentralized. A distributed network of hobbyist printers can produce hundreds of thousands of identical objects in weeks, without any coordination overhead worth mentioning.

3D printing has quietly arrived in enough homes to matter. Good reminder.