01
The Provocative Thesis
Angle: Standalone thought-leadership. No session branding — works cold, for reach.
Generating code got cheap. Judgment got expensive.
A decade ago, a working prototype took weeks. A few years ago, days.
Today, an AI hands you 75% of a working service before your coffee's done.
Nobody puts this part in the demo: who decides if that 75% is right?
Not the model. It doesn't know your business, your load, or your last
3am outage. That's still you.
The engineers losing their edge right now aren't losing to AI. They're
losing to engineers who got faster at the one thing AI can't do —
deciding what's worth building, and catching what's wrong before it ships.
Cheap things get copied. Expensive things become your moat.
Judgment just became the moat.
02
The Authentic Recap
Angle: Use only if you actually delivered this session series — reads as genuine, ties to real work, natural soft CTA.
I just wrapped 3 sessions teaching engineers how to actually work with AI.
Here's the one idea that mattered more than any tool or prompt:
You're not being paid to write code anymore. You're being paid to know
when the code is wrong.
Session 1 was about judgment: AI can generate a service in seconds —
should it even be a service? An event? A scheduled job? A column on a
table you already have? The model won't ask that question. You have to.
Session 2 was about systems: the same "processing your payment" screen
can mean success, a retry, or a stuck queue that needs a human. AI can
generate the boxes. It doesn't design the system, and it doesn't know
which failure mode you're actually in.
Session 3 was about directing AI itself: writing a plan before code
(a plan is a cheap place to catch a mistake — code is an expensive one),
and giving your agent real tool access so it verifies its own work
instead of waiting on you at every step.
One stat from that last session still surprises people: a METR study
found experienced developers were 19% SLOWER when using AI on code they
already knew — while believing they'd been faster.
This isn't an anti-AI take. I used AI to help build half of these
lessons. It's the opposite: AI rewards people who already know what
good looks like, and punishes people using it as a substitute for
thinking.
The tool got better. The judgment requirement didn't go away. It just
moved up a level.
What's the one thing you had to unlearn to actually get good results
out of an AI coding agent?
03
The Tactical Listicle
Angle: Highest save/share potential. Scannable, immediately useful, no story required.
5 things that separate engineers who get real work out of AI coding
agents from engineers who get impressive-looking drafts:
1. Plans, not prompts.
Before any code gets written, the agent writes a plan to a file — and
you read it. A wrong plan costs a paragraph. A wrong implementation
costs a branch.
2. Rules files, not repeated corrections.
If you've corrected your agent on the same thing twice, that correction
belongs in a CLAUDE.md / AGENTS.md file, not your memory. It should
load itself, every session, forever.
3. Skills, not raw prompting.
"Make a dashboard" gets everyone the same purple-gradient template.
A real brief plus someone's encoded design expertise gets you something
that looks intentional. The model didn't get smarter — the knowledge
got written down.
4. Real tool access, not a suggestion engine.
An agent that can write code but can't run it just stops and waits for
you at every step. Give it a CLI, a browser, a test runner — and it
closes its own loop: act, observe, correct, repeat. One benchmark: the
same model went from solving 1.3% to 12.5% of coding tasks just by
being able to execute and read the result.
5. Verification, not vibes.
Fast isn't the same as right. A study on experienced developers found
they were 19% SLOWER with AI on code they knew well — while believing
they'd been faster. Speed without a verification signal is just a
faster way to ship wrong.
The common thread: stop treating your chat with the AI as storage.
Chat is RAM — it slides, it compacts, it forgets. Put what matters on
disk.
04
The Minimalist / Rhythm Post
Angle: Short-line whitespace format LinkedIn's algorithm favors for pure reach. The mystery is the hook.
You used to see an app.
Now you see a system.
You used to write the code.
Now you write the judgment.
You used to trust the chat window.
Now you write it to disk — because chat is RAM, and RAM forgets.
You used to ask "can AI write this?"
Now the only question that matters is: can you tell when it's wrong?
Generating code got cheap.
Judgment got expensive.
Act accordingly.
05
The Contrarian Stat Hook
Angle: Counter-narrative — opens against the hype, stands out in a feed full of "AI 10x'd my output" posts.
A study just found experienced developers were 19% SLOWER when using AI
to code — in codebases they already knew well.
And they believed they'd been faster.
Not because AI is bad. Because speed without a verification signal
isn't speed. It's just a faster way to produce something plausible
that's wrong.
Meanwhile, the same underlying model, given real tool access — the
ability to run tests, read the failure, and fix it — went from solving
1.3% of a coding benchmark to 12.5%. Same model. Only difference: it
could check its own work.
That's the whole story of working with AI right now, in two numbers:
Humans get slower when they skip verification and trust the vibes.
Agents get dramatically better when you force them to verify.
The lesson isn't "don't use AI." It's that whoever is doing the
verifying — human or agent — that's the actual job now. Everything
else is autocomplete.
I dug into this building a training series on directing AI coding
agents properly. Happy to share specifics if useful — plan docs, rules
files, closing the agent's feedback loop, all of it.