The letter

I wrote a post a while back: “A letter to my fellow software engineers.” I warned about AI dulling our standards, about outsourcing our thinking, about the trap we were all walking into. I meant every word. And then I became the warning.

The FOMO

Our company pivoted. Hard. AI everywhere, all at once. Everyone around me was using it, generating code, reviewing PRs, writing docs. The momentum was relentless.

I felt it: that quiet panic, the fear of being left behind. Suddenly I wasn’t “the guy who warns about AI slop” but the guy not using AI, the skeptic, the one who’d get left in the dust. I didn’t want to be a dinosaur.

So I dove in. Hard.

The fall

I started using AI for everything: every line of code, every commit message, every design decision. I wrote maybe 1% of the code myself; the rest was prompt, copy, paste, tweak, ship.

And you know what happened? I embarrassed myself, multiple times, on PR reviewers.

Not on the hard stuff, not on obscure domain logic that an AI couldn’t possibly understand. On basic things, things I should have caught in seconds: null pointers, off-by-one errors, a function that was clearly doing the wrong thing but the tests passed because the tests were also AI-generated.

I’d stare at the PR and think: “Did I really miss that?” The answer was yes, because I wasn’t really reviewing; I was vibing. Just like I warned everyone about. The trap from my own letter, lived firsthand.

Building my own answer

I’m a terminal guy: TMUX, Nvim, opencode, keyboard everything. I’ve spent years tuning my setup, and I love it. The existing AI coding tools didn’t fit; they were tied to specific editors like Claude and Cursor, browser interaction with local and remote agents, all of them wanting me to work their way. Nothing worked the way I work.

So I built my own, kanabanana. I built it because I wanted to know (genuinely know) whether AI could work if you controlled every variable, if you designed the interaction exactly the way you wanted.

No editors, no walled gardens. Just my terminal, my agent, and a workflow that made sense to me.

It imports Jira tickets and creates internal kanabanana tasks. The agent researches and notifies me when it needs input. Swim lanes show what needs attention. GitLab integration interacts with MRs, comments on MRs, pipeline failures, self-reviews on failure, and checks logs. It can drive itself to success, and I can talk to it with voice-to-text when I’m in flow. Long context is handled with kanabanan thus saving on tokens without polluting the repository. It uses the code style I want. It’s mine, built my way.

The win

Two-week sprint delivered in three days, using kanabanana with the agent doing most of the heavy lifting.

I won’t lie, it felt good. Maybe I was onto something, maybe the approach had legs, maybe the scared dinosaur could learn new tricks after all.

The honest ceiling

And yet, even with custom tooling built exactly my way, every variable under my control, the code quality still feels bad. At this moment in time, it’s just not there yet.

Expensive models produce a lot of slop; open-source models produce a lot of slop. Clever orchestration (targeted, focused, short context) narrows the gap but doesn’t close it, not even close to what seasoned engineer could produce.

I look at what we have today versus few years ago: the ChatGPT era, massive GPU farms, the entire internet scraped, public GitHub scraped, paying customers’ inputs and outputs used for training. And we’re still producing slop. We are still not there yet.

An army of really confident junior developers.

The new relationship

After the PR embarrassments, I went cold turkey: back to my keyboard, thinking before typing, reviewing with intent.

Now I offload only the dumb stuff to AI: repetitive code that would take me ten minutes or hours of uninteresting typing.

I start the code myself, do the “heavy lifting” and steer the agent: “This is the direction I want you to go.” Not “write this function for me” but “I’m going this way, help me fill in the gaps.”

AI is a tool, not a replacement. Use it deliberately. The same thing I said in that letter: it took falling into my own trap to really understand it.

I don’t have a one-sentence takeaway for you. Go try it yourself, see for yourself, make your own judgment. Make mistakes, make slop! But come back smarter! If you’re on a greenfield project, be smart: don’t let the tools run you.

Maybe you’ll find something I couldn’t, maybe the ceiling is higher in your domain, maybe the scared dinosaur was just too old to adapt. Or maybe, just maybe, we’re all still figuring this out together.

I know where I stand right now. Ask me again in a year.

Here I go warning you again.

These are my personal opinions and are not related to the company I work for.