The four habits of AI-era engineers

1. The four habits

There are four habits that show up in every AI-era engineer who stays sharp. Other habits help. These four are the floor. If you're not doing them, you'll feel the field pulling away from you. If you are, you'll feel it pulling you forward.

None of them are exotic. The discipline is in doing them consistently, not in inventing them.

2. Habit one: read code you didn't write

Every week, read code that came from somewhere other than your own keyboard.

Open source projects you use. Read the source. Trace how a function you depend on works. Other engineers on your team. Read their PRs, not just to approve them, but to learn how they think. The model's output. Read what it produced today — not just the green parts that worked, but the parts you had to fix.

Reading is how you build taste. Taste is what tells you, without reasoning it out, that a piece of code is going to be a problem. Without taste, you can't review the model's output critically, because everything will look fine on the first pass.

The engineers who skip this habit can write code, but they can't read it well. They miss things. They ship things they shouldn't have. The reading habit is what keeps that from happening.

3. Habit two: write specifications

Write specifications, for things small and large.

For a feature you're about to start. For a tiny utility script. For the change you're making to a file this afternoon. The specification can be three sentences. It just has to exist before the code does.

What the habit teaches: clarity transfers. The act of writing what you want, before writing the code, sharpens what you want. Most engineers think they know what they want until they try to write it down. Then they realize they don't, and the specification is where they figure it out.

In the AI era this habit matters double. The model takes your specification as its starting point. A fuzzy spec produces fuzzy code. A precise spec produces precise code. The quality of what you ship is now directly downstream of how clearly you can state what you want.

4. Habit three: verify aggressively

Verify everything. Trust no output without checking it.

Tests are the obvious form. Write them. Run them. Add them to code that didn't have them. Types are another form — pick a language with a type system and use it well. Runs are the cheapest form — when you change code, run the code and see what happens. Eval sets are the form that matters most for AI work — write a small set of inputs and expected outputs and rerun them when you change a prompt or a model.

The habit isn't "test occasionally." It's reflex-level. You finish a change. Before you say it's done, you've confirmed it. By the time someone asks "did you test it," you've already answered the question for yourself.

The engineers who verify aggressively ship fewer bugs and develop sharper instincts for where bugs hide. Both compound.

5. Habit four: ship small things

Ship small things, often.

Real things. With real users, even if the user count is one. Real bugs. Real feedback. Real consequences for shipping the wrong thing.

The small thing is more valuable than the big thing, because the small thing ships. Most engineers who try to grow with one big side project finish nothing. The engineers who ship ten small things in a quarter learn ten times as much.

The shape doesn't matter much. A script. A tiny tool. A page on your blog. A pull request to an open source project. A weekend app for yourself. What matters is that it's done, used, and you saw the consequences.

Shipping is what closes the loop between what you thought and what's true. Until you ship, you're guessing. After you ship, you know.

6. The compounding

These four habits are independently useful. Together they compound.

Reading builds the taste that makes specifications sharper. Specifications make verification meaningful, because you can check against what you wanted. Verification produces feedback that improves your reading. Shipping forces you to do all three under real conditions.

A year of these four habits, done consistently, separates an engineer from a peer who started at the same place. Three years separates them by a level.