I recently saw DHH’s keynote at “Railsworld 2026” and it has spurred my plan to share the story of my epiphany (related to agentic coding, ofc). No, don’t worry, I’m not going to describe my full journey with LLMs (that would be a long one …), nor am I going to rephrase DHH’s points - the plan is to:
- focus on my “a-ha” moment (when & how I learned there’s no coming back)
- describe how I’ve learned to use it in a way that catapulted my productivity through the roof
My game-changer was Opus 4.7, and I had the realization in mid-April 2026. I wasn’t coding that much at that time (they don’t pay me for coding nowadays - more on that later), but I’ve used it regularly to “talk to the codebase” - mine the knowledge from code, challenge my thinking, explore scenarios, and draft development plans.Opus 4.5/4.6 were already quite badass, but with 4.7 I couldn’t help but get the impression I started … trusting the model.
Don’t get me wrong - not trusting unconditionally, quite the opposite - but it was consistent enough, logical enough, and transparent enough that I knew I could turn it (wrapped in a sufficient number of guardrail/check/test/eval layers) into a real wingman that can be relied upon.
Still, at this point I didn’t trust Anthropic (well, I still don’t - to some degree), so my first decision was to … buy the most powerful MBP at that time (M5 Max 128 GB RAM) as a stable local alternative in case Claude goes down, the token price gets unbearable, Anthropic degrades model quality substantially, or (last but not least) Trump goes bananas with restrictions and bans (again).
Long story short, here's what happened in the next four months:
- I’ve set up my rig for local, agentic coding (with OpenCode, ollama, mlx, llama.cpp, etc.)
- I’ve started "pet" projects - the first one in the final days of May, the second at the beginning of August, and finally the third and fourth in September.
- I’ve raised my Anthropic subscription first to MAX x5 and then (after hitting the wall too soon) to x20
- At the beginning of July 2026, I raised my OpenAI subscription to the top tier as well (after the release of GPT 5.6 Sol)
- I’ve kept some other lower-tier subscriptions (e.g., Cursor/Grok), mostly for adversarial cross-checks
- At the moment of writing these words (28th of September), GitHub has registered 1834 contributions co-authored by LLMs and myself - to those specific four “pet” projects only. The biggest project is already >200k LoC; the number of daily added+removed LoC was up to 20k (yes, these are vanity metrics that represent output, not outcome - I know, but first things first)
- I typically “develop” 2-3 projects in parallel, feeding the agents asynchronously prepared plans and pushing them forth via remote control (on my phone) - that means 6-12 agents working in parallel for at least a few hours per day.
- Each week I consistently hit the limits (>90%), but as I adjust along the way, I time it properly so I never run out of tokens mid-week (I don’t buy those in “pay-as-you-go” API models, btw).
When it comes to the “pet” projects, here’s what “pet” means in that case:
- A real app (published on GitHub, as OSS with a permissive license) that is/will soon be used in a professional setting (it actually solves real, pressing need(s) of my teams)
- I do develop it in my spare, private time, using my own hardware and my own licenses - why so? To allow free, unconstrained experimentation w/o breaking any company rules (we’re subject to many legal regulations, specific to the FinTech and PayTech industries) - as a CTO, I could bend many walls, but that would also send a very bad signal to all the other engineers; that’s why I decided not to.
- As my days are quite packed (with … you know … CTOing …), I develop these apps after hours - which practically means evenings, nights, and weekends. That wasn’t w/o an impact on my private life (especially sleeping hours …), but fortunately - due to the asynchronous nature of agent collaboration - I’ve managed to minimize & contain the negative effects.
- Needless to say, all apps are greenfield; there is/was no other “agent shepherd” co-working on them (so there was no interference with another agentic firehose ...), and I’ve picked the problems to be solved very carefully: these are auxiliary, internal apps for SDLC processes, not externally exposed business-critical services responsible for the actual transfer of money; I’d rather not experiment on the company’s core business that way …
- To speed things up, I’ve forced a lot of sharing between projects: same tech stack, same UX/UI design fundamentals, same authorization model, same feature flag design, etc., which has enabled faster porting so I could focus on modeling and building features.
OK, that's enough for part 1. Stay tuned for the following posts where I’m going to describe:
- How I evolve my way of working with AI agents?
- How my current setup looks?
- How I work with the specs/documentation?
- How I optimize agent flows (and what the " valves " are to fiddle with)?
- Why I think that slop is a skill issue?
- Where agentic coding won’t work?
- What has surprised me most while working with agents?
- How does shepherding agents differ from managing human developers?
- What kind of “good practices” have I developed with my agents?
- And much, much more
I plan to release a new episode (600-1000 words) at least once a week. Let me know if you enjoyed the reading so far - in the comments or on social media. Thanks in advance!
