Every executive makes the same first call. I’ve heard it 50 times:

“Hey, uh, I got your name from [mutual contact]. We have a... situation. Our [system] is [broken] and we have [important event] in [absurdly short timeframe]. Our team says it’s impossible to fix quickly. But [mutual contact] said you might be able to help?”

They’re asking a stranger to save them from their own organization.

“I can take a look right now. Send me access.”

The relief is immediate. Not because you’ve fixed anything - you haven’t even seen the code yet. They’re just happy someone said yes without a 6-week discovery phase.

What Executives Actually Want

You think executives care about your technical decisions. They don’t.

Here’s what’s actually happening: The board meeting is next week. Their “platform” is Brad’s laptop running cron jobs. Due diligence starts Monday. Their CTO keeps saying “it’s complex” which everyone knows means “we have no idea.”

They don’t need perfect code. They need plausible deniability.

When they hire a dev team, they’re buying blame diffusion - “We have 50 engineers on this.” When they hire you, they’re buying speed - “It’ll be fixed by tomorrow.”

One makes them look responsible. The other makes the problem go away.

The Speed Game

Here’s the consulting secret nobody talks about: AI turned every decent developer into a 10x developer overnight. Not in quality - in speed. The executive doesn’t know the difference.

Get access to their codebase. Feed it to Claude/GPT/whatever. Build context in 2 hours that used to take 2 weeks. Find the obvious issues their team has been “investigating” for months. Fix something - anything - by end of day.

You’re not a genius. You just have better tools and no organizational dysfunction slowing you down.

Example: Client hired me for API optimization. While they were explaining the problem, I found their auth tokens were stored in plaintext. Fixed it during the call. Suddenly I’m their security expert too.

That’s not expertise. That’s just grep and common sense. But to them? Magic.

The Fear Economy

Real call from last month:

“The enterprise client is asking about timeout errors. I have to pretend I understand our infrastructure. My CTO will make it sound complicated. The client will hear ‘we don’t know.’ That’s 30% of our revenue gone.”

They’re not really hiring you to fix timeouts. They’re hiring you to protect them from looking incompetent in front of people who matter.

Every technical executive knows their team is lying to them. The offshore contractors billing 40 hours for 4 hours of work. The “senior” engineers who don’t understand the product. The CTO who’s three years out of date.

They know. They’ve always known.

You’re not there to fix the technology. You’re there to fix the politics without anyone admitting the politics need fixing.

The Dependency Trap

Around month three, they always ask: “What would it take to bring you in full-time?”

They’re not recruiting. They’re panicking. They’ve realized their entire technical operation depends on someone they don’t control.

Say no. Always say no.

The moment you’re full-time, you become part of the dysfunction. You’ll sit in meetings. You’ll write documentation. You’ll get pulled into politics. Your velocity drops 90%. You become what you replaced.

Stay external. Stay fast. Stay expensive.

The $500/Hour Reality Check

Yes, I charge $500/hour to be a human API wrapper. Yes, it’s absurd. Yes, they pay it happily.

Why? Because their lawyer charges $800/hour to also Google things. Because their McKinsey team charges $2M to produce PowerPoints saying “digitally transform your infrastructure.” Because spending $50K to save a $5M contract is elementary math.

You’re not charging for code. You’re charging for speed, availability, and the psychological comfort of having someone competent on speed dial.

The Uncomfortable Truth

Most of my fixes are ChatGPT solutions with 10 years of context about what actually matters in production. Their team could do the same thing if they:

• Had no meetings

• Had no process

• Had no fear of being fired

• Had permission to use AI

• Actually understood the business problem

But they can’t. So you can.

The client doesn’t want to hear “I had AI analyze your codebase.” They want to hear “I’ve seen this pattern before.” Fine. Both are technically true.

What This Actually Is

You’re not a revolutionary. You’re not disrupting anything. You’re a pressure release valve for organizational dysfunction.

Companies are spinning apart from their own complexity. Their teams are paralyzed by process. Their executives are drowning in problems they don’t understand. You’re just someone who shows up without baggage and fixes things before they explode.

It’s not noble. It’s not innovative. It’s just arbitrage - the gap between what AI can do and what organizations are allowed to admit AI can do.

The corporations are putting on AI theater, pretending to transform while accomplishing nothing. You’re selling them actual results while they figure out their narrative. Eventually they’ll catch up. Until then, you’re running a very profitable race against organizational inertia.

Stop pretending you’re special. Start admitting you’re just fast. The invoice amount stays the same either way.

In this month’s news, Deloitte got caught submitting hallucinated academic citations to the Australian government and you know what? Good. Fuck them.

Not because they used AI. I use AI. I make a living on Claude writing code while I argue with boards and regulators about compliance. We are doing the same job. The difference?

I READ THE FUCKING OUTPUT.

Revolutionary concept, apparently.

Last week Claude generated a piece of config that looked beautiful. Clean. Elegant. Would’ve passed every code review at your startup. Also would’ve exposed our entire banking infrastructure to the public internet. Caught it on line 683. Because I read line 683. Because that’s my fucking job.

But lawyers billing $800/hour can’t be bothered to Google whether their cases exist. Consultants charging millions submit reports that sound like ChatGPT having a stroke. Developers - DEVELOPERS, MY PEOPLE! - push and approve each other´s untested AI completions to prod. To PROD. Payment systems. Auth flows. Database migrations. Just... yolo, let’s see what happens.

It’s insulting to the client. To yourself. You’re charging price-of-a-house money and you can’t even be bothered to read what you’re selling them? Fuck you.

The Scam Was Always There

Here’s what kills me: everyone’s acting surprised. “Oh no, AI makes mistakes!” “Quality is declining!” “Professional standards are eroding!”

No. Stop. Here’s a hot take:

That lawyer who submitted fake cases: Do you think they were carefully reading contracts before? They were find-and-replacing names in templates. The Deloitte consultant? Wikipedia to PowerPoint converter. That developer shipping untested code? Brother, they never wrote tests anyway.

AI just made it obvious. Stripped away the busywork that was hiding the fact that nobody was doing the real work.

I generate 50 changes of all sizes and criticality a week with AI, code, reports, emails, the works. You know what that’s like? It’s drowning in almost-right. Every single one looks good at first glance. Most ARE good. Some are 95% perfect with 5% devastation hiding in the middle. Like that time Claude helped us restore a corrupted database. Deleted 150,000 production records. Took me 2 hours to unfuck that (PITR, people, saves lives). On the incident report, my name; not Claude’s.

The thing is - I caught dozens of other fuckups before they hit prod. Why? BECAUSE I READ THE CODE.

Not skim. Not glance. Not “looks good, ship it.” Actually read. Line by line. Understanding what each part does. What it affects. What breaks when it breaks.

This is apparently a superpower now.

Your Reviews Are Worthless And Nobody Gives A Shit

“But we have review processes!” Yeah? Your review process is two people adding “Please review” and “looks good to me” without reading. This applies to everyone from the salesperson to the CEO.

I know because I’ve watched you do it. Senior engineers approving 10,000 line PRs in 30 seconds. “Looks good to me!” How? HOW does it look good? You didn’t read it. You saw green checkmarks from the linter and called it a day.

The partners at BigLaw and Big 4 built these elaborate quality theater productions. Six rounds of review! Quality committees! Professional standards boards!

All of it, every single layer, was just people assuming someone else was reading it.

Junior generates with AI -> Senior “reviews” (doesn’t read) -> Manager “approves” (doesn’t read) -> Partner signs (definitely doesn’t read) -> Client gets fucked -> “AI error”

No. It was 4 human errors. The error of not doing your fucking job.

When Claude writes code for me, I treat it like a gifted but psychotic junior developer. Brilliant one moment, actively trying to drop production tables the next. No malice, just... confidently wrong about things that matter.

My review process:

• Assume it’s broken

• Assume it’s insecure

• Assume it missed the requirement

• Prove otherwise

That’s not AI-specific. That’s how you should review ALL work. But nobody does. They see something that looks passable and ship it.

You know what happened when I missed one review? When I got tired and just trusted Claude’s Terraform? Misconfig of a stream cost us $2k in AWS credits over a day. Alerting caught it, thank fuck, but it was still my mistake. Mine. Not Claude’s. Mine.

The Golden Opportunity

Want to make a killing professionally in 2025? Please subscribe to my paid content lol.

Joking aside, here’s the entire requirement:

That’s it. The bar is so low it’s underground. Clients and employers are desperate for someone who cares; you just have to be slightly better than absolutely terrible. While everyone else is writing think-pieces about “AI governance” and “the future of work,” you just... do the work.

So here’s the thing: this window won’t last. Eventually, the bar will rise back to ground level. Basic competence will stop being a superpower.

But right now? Right now you can dominate just by caring a bit. Just by reading to line 683. Just by googling whether citations exist. Just by reading every line, catching every subtle fuckup, owning every outcome. because that’s what they’re actually paying for. Not the code. The judgment. The ownership. The giving-a-shit.

AI writes the output. You own the mistakes. That’s the deal. And if you’re not willing to make that deal, stop pretending you’re a professional.

You’re just an expensive API call who’ll be replaced by a Chrome extension.

The weird part isn't that it works. The weird part is how boring it's become.

Background Noise

Twenty years touching computers for money. Started when PHP4 was hot shit. 10 years of freelance, hundreds of clients, then the corporate ladder — developer, lead, manager, CTO. Had a team of fifty at the peak. Fintech, crypto, hot shit all the way. By the end of a career built on shipping fast and good software, I was spending most of my time in meetings about why we weren't shipping, while secretly knowing it was because I was in meetings about why we weren't shipping. Money was good enough to keep the pretence for a while.

Left that world a year ago. Not dramatically. Just stopped showing up to the office. Figured I'd freelance for a bit, clear my head, maybe build something nobody wants. Done with boardroom politics and the illusion of busyness. Done with pretending it mattered. I moved to the sun.

Then AI happened. Not as a revelation but as a tool. Like discovering you can use a drill instead of a screwdriver. Except the drill also knows how to build the entire cabinet. A tool that felt enough like magic that learning to master it was exhilarating. I had fun shipping again

Real-life example

Three clients. All B2B. All past product-market fit but held together with prayer and if…else .

Client 1: Fintech that processes business loans. Eight years old. Still running the original Django monolith. Third outsourced dev team. The kind of codebase where every file has a comment from 2019 saying "TODO: fix this properly." Their AWS bill is $6k/month. Half of it is resources nobody remembers creating.

Client 2: Healthcare scheduling platform. HIPAA compliant in the sense that they check a box saying they're HIPAA compliant. PostgreSQL database with 400 tables because every feature got its own schema. The original developer named all foreign keys `thing_id` regardless of what they reference.

Client 3: Payments processor for Latin American markets. Integration with 17 different FIs, each with its own idea of what "ISO" means. Their reconciliation system is a cron job that emails when numbers don't match.

These aren't scrappy startups. They have real customers, real revenue, real regulators asking questions. They also have systems that would make you weep if you looked too close.

Monday Through Friday

Here's last week. Not cleaned up. Not dramatised. Just what actually happened.

Monday, 9:47 AM Client 1 messages. Their loan approval system is approving everything. Not most things. Everything. Even test applications for negative amounts.

I pull out the approval function. 400 lines of nested conditionals that hurt my eyes. Ask Claude what's wrong. It spots it immediately: someone changed the math in the credit score check. Probably a typo. No unit test. Been live since Thursday.

Fix takes five minutes. Explaining to their board why they approved $60k in loans to people with 200 credit scores will probably take a while longer, but not for me.

Monday, 2:15 PM While Client 1 panics, I'm building Client 2's new audit log system. They need to track every click for compliance. I describe what they want to Claude. It writes a middleware that logs everything. Too much everything: passwords, SSNs, the works. Tell Claude that's bad. It apologises and fixes it. Now it logs everything except sensitive data. Ship it.

Tuesday, 10:00 AM Client 3's reconciliation is off by $400k. Not missing. Just... somewhere. They think it's timezone-related because it's always timezone-related. I feed Claude their transaction logs. It's not timezones. It's that their Colombian bank returns amounts in centavos but their documentation says pesos, so they've been dividing by 100 twice since they added the currency.

The fix is one line. The cleanup takes two hours of running SQL that Claude writes while I watch TV.

Wednesday, 3:00 PM Bad day, not feeling it. Claude triages emails and surfaces only the most important stuff. We make runbooks for our next sessions.

Thursday, 8:00 AM Routine maintenance for Client 2. By which I mean I ask Claude to `Look into the db logs and the codebase for SQL performance issues`. It pretty much gets it straight away, focusing on not only on the obvious but also finding weird anomalies I wouldn’t have looked at. It fixes a bunch of n+1 queries, adds twelve indexes and rewrites a join that was accidentally cartesian. Page load drops from 8 seconds to 0.3 seconds.

They ask what I did. I could explain about query planners and index selection. Instead I say "optimisation" and they're happy.

Thursday, 3:00 PM Client 3 emergency. Bank API changed without notice. Everything's failing. They sent documentation. It's in Portuguese. I don't speak Portuguese. Claude does. Twenty minutes later we're processing payments again.

Friday, 10:00 AM Weekly check-in. I join, camera off, while making breakfast. Client 1 wants to know about scaling strategies. I ask Claude to write a scaling strategy while making coffee. It's probably better than anything I would have written. More thorough, too. I read and cherry pick the good parts into an actionable plan. Client loves it.

Friday, 2:00 PM Invoice time. I bill hourly but I'm not tracking hours. I bill based on value delivered. Fixed a loan approval bug that could have cost millions? That's $8k. Audit logging system? $12k. Found missing $400k? $5k.

Nobody questions it. They're used to paying consulting firms 5x more for PowerPoints. I give them results and peace of mind.

The Uncomfortable Parts

Sometimes I'll be on a call, sharing my screen, and realise I'm just reading Claude's response out loud like I thought of it. The client's nodding along, impressed by my insight. I'm literally reading from another tab.

There's a particular loneliness to this. I solve real problems for real money, but I don't actually solve them. I just broker solutions between clients and an AI. I'm a very well-paid middleman.

The code isn't the value. Never was, but now it's obvious.

Client 1 doesn't pay me to write Django. They pay me to know that their loan approval breaking means regulatory breaches, that the fix needs audit trails, that the board needs a story that doesn't involve incompetence.

Client 2 doesn't need clean code. They need someone who knows HIPAA means you can't log SSNs even accidentally, that auditors care more about documentation than implementation, that compliance is mostly about proving you tried.

Client 3 needs someone who understands that banking is held together with Excel and email, that every country has different rules, that the technical solution is usually easier than the political one.

Claude can write good enough code. It can't sit in a meeting and know when the client is lying to themselves about what they want. It can't tell when a technical requirement is actually a political problem. It can't navigate the human mess that surrounds every system.

The Trajectory

I'm billing between $60-80k per month across multiple clients. My costs are:

- Claude Max: $200

- ChatGPT Pro: $200 (backup)

- AWS (personal): ~$1000

- Rent/bills/food: ~$2000

The math is absurd. One client pays me more than my entire cost structure. But what's their alternative?

They could hire a team. They've tried. Teams need management, coordination, meetings. Teams build what they're told, not what's needed. Teams have opinions and egos and sprint planning.

Or they get me. No meetings unless necessary. No opinions unless asked. Solutions that work today, not architectures that might work someday.

Sometimes I think this isn't sustainable. Not because AI will replace me — it already has. But because eventually clients will realise they can use AI directly.

Except they won't. Same reason I don't fix my car even though YouTube exists. Same reason they hired consultants before AI existed. They need someone to blame who isn't them. They need someone who knows what to ask. They need the confidence that comes from someone else taking responsibility.

The real trajectory is weirder: I'm becoming less technical and more... whatever this is. Therapist for broken systems. Translator between business needs and AI capabilities. Professional responsibility-taker.

What it actually feels like

Lonely. Productive. Boring. Profitable.

I ship more in a week than I used to in a quarter. But there's no satisfaction in it. No clever solution I worked out. No architecture I'm proud of. Just prompts answered and code that works.

Some days I feel like a fraud. Other days I check my bank balance and feel like everyone else is trying too hard.

Mostly, I feel like I'm living in a gap. The space between AI being good enough to replace most developers and everyone realising it. It's a profitable gap. But it's still a gap.

The Truth

My clients' systems are held together with the digital equivalent of duct tape and prayers. Every codebase is a horror story. Every architecture is a compromise that metastasised. Every deployment is a risk.

Claude makes it faster, not better. Instead of taking six months to build something that barely works, we can now build it in six days.

Is it good enough? The systems process millions without falling over. The audits pass. The customers don't complain more than usual.

That's not a ringing endorsement. But it's the truth. Most software is garbage. AI-generated garbage isn't notably worse. It's just faster to produce and easier to replace.

The real question is whether human code was ever good in the first place.

Based on what I've seen in twenty years? We've been shipping "good enough" and calling it excellence all along.

At least now I can do it in the sun, in my underwear, billing Fortune 500 rates while an AI does the actual work.

That's the consultancy business in 2025. It's absurd. It works. I'm not sure what that says about any of us.

Forty-five minutes later, he looked like he’d swallowed battery acid.

“They want us to make withdrawals take six hours on purpose?”
“Yes.”
“But we built instant processing. That’s the whole value prop.”
“They need time to check WhatsApp.”
“…WhatsApp?”
“That’s where their risk team lives.”

That was the day he learned: everything we built was wrong. Not technically wrong. Business wrong.

Why Sales Notes Won’t Save You

After that call he asked for the sales notes. Here’s what they said:

Client interested. Needs review workflow. Budget approved. Decision by EOQ.

Here’s what he actually heard in the room:

• They called our API “too complicated” (it’s REST, not rocket science)

• Trevor approves everything manually, because Trevor is the system

• Risk checks happen in a WhatsApp group

• They want slower processing, not faster

• Their reconciliation engine is Google Sheets

• They adore their current terrible setup

Sales didn’t note any of that. Why would they? Sales already knows every client has a Trevor and a spreadsheet. That’s not worth writing down.

For a developer, though, that’s the entire game.

The Exercise That Changes Everything

Stop asking sales what customers want. Start listening to what they actually say.

Five calls with customers/leads. One week. Say nothing. Write everything.

Note down:

• Every time they mention a name (that person is a dependency)

• Every tool they mention (that’s your real competition)

• Every “we just…” (that’s the actual requirement)

• What gets them excited vs what makes them glaze over

• The exact words they use vs the jargon you use

By call #5, the lightbulb goes on and understanding starts to emerge:

• They don’t have “users,” they have “traders”

• They don’t want “authentication,” they want “login”

• They don’t need “real-time,” they need “same day”

• They don’t trust “automated,” they trust “Sarah checks it”

How Profiles Actually Form

It’s not that every customer falls into neat buckets. It’s messier. But patterns add up.

• One client has a Trevor. Another has a Sarah. Another has a “manual risk process.” Same thing, different accent.

• One has a spreadsheet, another has a custom PHP monstrosity, another has Notion tables. All roads lead to Excel.

• One says they want AI, another says they want “insights,” another says “competitive edge.” All of them want a buzzword they can drop in board meetings.

Listen long enough and you stop hearing “random chaos” and start seeing profiles emerge. Not clean personas, but recognisable archetypes of dysfunction. Sales spots them instantly. Devs won’t — unless they’re in the room.

What Developers Learn When They Actually Listen

Real calls sound like this:

• “Your risk system is too aggressive.”
  Translation: it blocked fraud but also their biggest client.
  Lesson: They’d rather risk fraud than lose a whale.

• “We need audit trails.”
  Translation: a regulator asked once.
  Lesson: Nobody reads them. They just need to exist.

• “Can you integrate with our existing systems?”
  Translation: Steve built something in PHP in 2011 and everyone’s scared of it.
  Lesson: You work around Steve, not replace him.

• “We want AI-powered insights.”
  Translation: competitors say they have AI.
  Lesson: They want to say AI, not use AI.

This is what reality looks like from the point of view of the people who buy. And it’s all in the call if you want to listen.

Enlightenment

By the tenth call, you’ll likely realise:

• Nobody gives a shit about your clean architecture.

• Manual processes aren’t bugs, they’re features.

• Your competition isn’t other software, it’s Excel and WhatsApp.

• Sales wasn’t lying or clueless. They were translating customer reality into something you could tolerate.

In other words, after those five calls you’ll either quit in disgust or become 10× more valuable. Both responses are valid. Choose wisely.

The Choice

Keep building what’s “right” and wonder why nobody buys it. Keep butting heads with sales and waste resources in pointless back and forth until you bleed out.
Or spend five hours listening to actual customers and finally understand what to build.

Sales lives in these calls. They already know. You just don’t believe them because it sounds technically wrong.

But technically wrong that sells beats technically right that doesn’t. Every time.

Now AI can code, faster and better than you. It doesn’t care if the feature makes sense, or if the idea is elegant. It just gets the outcome done.

It can’t sit in a sales call though, understand the customer and make informed decisions that may or may not spit in the face of “well-engineered”.

If you can’t either, you’re finished.

Important P.S.

Sales won’t invite you unless you promise to shut the fuck up. That’s fine. You’re there to listen, not to explain why the customer is wrong about their own business. Worse case, get a recording, it’s not quite as good a lesson but serviceable.

A trillion dollars torched worldwide. Countless "AI transformation roadmaps" written. And for what? Models that choke on logic puzzles your kid could solve. GPT-4 fails Tower of Hanoi even when you spoon-feed it the algorithm. But sure—let's run another six-month discovery phase to "explore use cases across the enterprise."

While You're Writing Plans, Your Team Is Already Using It

Nobody in your company is waiting for the strategy committee.

• The finance analyst is copying transaction data into ChatGPT to find anomalies.

• The customer support lead is running angry client emails through Claude to draft "calmer" replies.

• The developers are dumping production error logs into GPT to debug at 2 AM.

No logging. No guardrails. No oversight. Just staff doing what works, faster than procurement can approve a license.

So when the auditor shows up, your "15-month rollout plan" won't matter. What will matter is that someone pasted raw customer PII into ChatGPT last quarter from a company laptop.

Executive Strategy Theater

A bunch of scale-ups I talk to are staging the same play:

• Phase 1: Discovery & assessment (6 months) - mostly politics

• Phase 2: Pilot programs (6 months) - build proof-of-concept nobody uses

• Phase 3: Enterprise rollout (12 months) - integration hell

• Phase 4: "AI Team" (ongoing) - maintain the thing that doesn't work

Ok, that’s how you do things in C-land. That's also two years to officially sanction what your team has already been doing unofficially since 2023.

Meanwhile, your competitor hired two engineers who spent a weekend and came back with AI-assisted ops that actually work. No deck. No steering committee. Just problems solved.

What Actually Works

The companies pulling ahead aren't running "transformation programs." They're doing boring operational hygiene:

• Audit reality: What tools are staff already using? With what data?

• Put in guardrails: Mask PII, log prompts, human review for production changes. Not a project. A checklist.

• Aim AI at grunt work: Reconciliation scripts, log analysis, documentation. The time-sink stuff nobody enjoys and sits at the bottom of the backlog.

• Measure actual impact: Deploy speed, error rates, support tickets. Not "AI readiness scores."

It's janitorial, not visionary. It also fucking works.

The Real Numbers

The 95% failure rate isn't because AI doesn't work. It's because leadership treats working tools like magic objects.

• Failed approach: €500k "AI program," custom model RFP, dedicated task force.

• Working approach: Create a task force, €200/month in GPT/Claude/Copilot accounts used by engineers to ship faster and screw up less.

One path produces PowerPoints, the other fixes production.

You don’t need an AI “strategy.” You need AI hygiene.

• Instead of roadmaps → Audit what’s already happening.

• Instead of “centers of excellence” → Train staff to use tools safely.

• Instead of “custom models” → Get really good at using the ones that exist.

You don’t have a calculator strategy. You don’t need an AI strategy. You just need to make sure nobody is dividing by zero in production.

The Actual Risk

Not machine consciousness. Not job extinction. The real risk of not controlling AI usage is operational stupidity:

• Support pasting full email threads with client data into free tools.

• Engineers deploying AI-written code they don't fully understand.

• Finance uploading transaction exports into public APIs for "analysis."

Tomorrow's governance headache shouldn’t take priority over today’s compliance breach...

Then we get to pure market forces. What do you think happens when the competition starts pushing features faster, tightening their operational resilience and getting hacked less?

The Bottom Line

The companies that survive won't be the ones with the most ambitious AI vision decks. They'll be the ones who figured out how to use flawed but useful tools safely, while everyone else was still "exploring use cases."

Good developers have already transformed their processes. They're shipping faster, debugging smarter, and solving problems while you're still writing vision statements.

The only question left is whether you're going to manage the risks they've already taken or spend another quarter planning to plan.

The air at the top was thin, an echo chamber of egos where opinions grew dirtier the higher you climbed. My mind shrank, my stomach turned to ulcers, and in a loveless marriage I felt myself suffocating. On paper I was winning, but in truth I was rotting.

When my last gig ended, it all stopped at once. My work, my personality, my life, the abyss left by the all-encompassing “C-level mindset” was so deep I fell into it headfirst and kept digging. Without it I had nothing, I was nothing, just a pile of cash I never deserved.

I decided then to end it.

More out of lack of perceived options than anything else. It felt like a good time to blow all my money and jump under a train. At some point I even looked up the times and places. Fun memories.

The car crash was exhilarating. Drugs, sex, festivals, a summer of pure debauchery in the sun. Self-destruction burns hot like passion and I was well on my way to ashes.

Then one day, a miracle happened. I met a person I should never have met and my world turned again, for the better this time. I found acceptance, love, and a connection I never knew existed. We had the same final plan, but once together it didn’t seem to make sense anymore to go through with it.

Through her I rebuilt myself, still am today. With constant honesty, kindness, and strength she taught me there could be another way, a soft and gentle way to live, in service of each other and our selves. I am forever grateful for this.

Today, I am better. Not good but better. I look back with no regrets but I am conscious of how close I got to never knowing true happiness and love.

This is to you who think about the end of the line. To you whose hope has left, to you whose purpose is gone. You are still here, and within you there is that person you crave to become. Don’t give up.

I love you.

The headline was everywhere: “AI will write 90% of code within half a year.”

Everyone had a take. Some cheered the revolution. Others declared the profession dead. Some said it would rot your brain. Others promised infinite productivity.

Flip a coin. You’d land on a loud opinion.

Here’s the truth: I’ve lived with AI in production for more than six months. Banking features. Infra. Real outages. Security holes. Audits. Money on the line.

And what I’ve learned is simple: developers aren’t obsolete. They’ve been promoted. Against their will.

What changed

The keyboard isn’t the bottleneck anymore. Typing is cheap. AI will scaffold the CRUD, draft the Terraform, spit out 10,000 lines of plausible code while you eat lunch.

The bottleneck is judgment. The job is ownership.

• Did you review intent, not just syntax?

• Did you notice the skipped constraint before it cost the client their license?

• Did you catch the overconfident garbage before it hit prod?

You don’t own the lines you type anymore. You own the blast radius of what you approve.

The flood

Here’s the fatigue part nobody warns you about.

Humans bury you in 5 PRs a week. AI buries you in 50.

Every one looks right at a glance. Most are 80–95% correct. The same hit rate I expect from a junior. But at scale.

That’s why people complain about “review fatigue.” It’s not that AI is worse. It’s that it produces the same mistakes faster. You drown in almost-right code until you stop reading carefully—or you miss the one that matters.

I missed one. Terraform config. Looked fine. Passed validation. Except it silently skipped a constraint and opened a regulated system to the world. Alerting caught it. But it was still my responsibility.

The rules don’t change

People keep drafting 60-slide “AI governance frameworks.” Forget it. The rules are the same ones we should’ve been enforcing on humans:

• Juniors don’t merge to prod. Neither does AI.

• Review logic, not commas.

• Automate the gauntlet: lint, tests, CI/CD, security scans.

• Pair AI with a human, don’t replace. AI + junior beats either alone.

• Define “done.” If you don’t, AI will invent it.

• Own the blast radius. “The AI did it” dies in audit.

AI isn’t alien. It’s just infinite juniors with no shame and no fatigue. Manage them the same way.

The job spec you didn’t want

Developers used to measure output in lines typed. Now it’s decisions approved.

• Less builder. More reviewer.

• Less typing. More triage.

• Less “I made this.” More “I take responsibility for this.”

That’s management. From day one.

And like every manager, you inherit fatigue. The flood of almost-right. The uncertainty of never being sure you caught everything. The knowledge that when it goes wrong, it’s your name on the blast radius.

Welcome to management.

The illusion of training

I had a junior spend a fortune on a dev bootcamp. His capstone CRUD app took two weeks. A good effort. Classic rite of passage.

We rebuilt it with Claude and v0 in ~20 minutes.

That’s not a dunk on him. It’s a signpost. The point of training isn’t syntax anymore. It’s judgment. It’s learning to specify well, to define “good enough,” and to own outcomes. And as such it requires a different kind of training.

Approve → improve → ship. That’s the real job.

Why it hurts

The loudest complaint you hear—“AI is almost right, but not quite”—isn’t about AI. It’s about the new job description.

You’re feeling what managers felt all along. The fatigue of endless output you can’t fully parse. The anxiety of decisions under uncertainty. The pressure of ownership without control.

Developers didn’t get replaced. They got promoted into exactly that. Overnight.

The verdict

Six months in, I’ll tell you what I know:

• AI writes the code.

• I own the mistakes.

• The bottleneck is judgment.

• The cost is ownership.

That’s the deal.

The code is Claude’s.
The breach is mine.

It’s the promotion nobody asked for. Take it every time.

When I took my (final?) leave from the corporate world last year, AI was the word in every executive’s mouth. Lots of wild predictions were thrown around, “Initiatives” were sponsored, then slashed by angry CISOs, everyone was vibe coding, no one had a clue.

So I decided to run an experiment to answer the questions on everyone’s minds: Is AI good enough to be used in production? If so, how? How will software engineering practices evolve? What are the skills that the engineers of the future should learn?

For the last 9 months, I have used AI in production systems, with real stakes, audits, regulators, real money. 0 to 1 MVPs, feature dev, infra, DevOps, SRE, accounting, governance, I have tried it all and lived to tell the tales.

I’m here to show you how to leverage AI coding tools as cognitive augmentation, to not only push software faster, but also safer, more secure and better than you’d ever be able within the normal constraints of the workplace. In my view, it enables engineering teams to achieve operational excellence at speed, by not taking the shortcuts they’d otherwise be forced into.

What you’ll find here:

• Prompts and playbooks to grow from vibe-coder to master operator

• Reflections on software engineering practices

• Field notes from actual disasters and last-minute saves

• Whatever else I feel like, this is a creative space

It feels SO GOOD to share this with you all. Thanks for reading.