From Saiyan to Super Saiyan 3: my journey building Agentikas with Claude

I grew up watching Dragon Ball. Goku's transformations — Saiyan to Super Saiyan, then 2, then 3 — always felt like an exaggerated metaphor for professional growth. Each level multiplied strength, but also the difficulty of staying in it. Strength wasn't free. It cost focus, sleep, versions of yourself that didn't come back.

The last six months building Agentikas Blog with Claude have made me think about that metaphor more than I'd admit sober. Not because I feel especially strong — but because each level demanded a different kind of skill, and the engineer who wrote the first commit doesn't look like the one writing this.

Regular Saiyan: the terminal and the model

The first month was clean. Me, an editor, Claude Code in one window, a fresh repo in another. Every feature was a conversation. I asked. Claude proposed. I reviewed, adjusted, approved. I shipped more in four weeks than in past projects in four months.

The dominant feeling was fresh velocity. Twenty years writing code and suddenly everything moved faster without quality dropping. Thinking before typing became the central skill — because my typing wasn't the bottleneck anymore, my thinking was.

If you'd asked me back then "what changed?", I'd have said "Claude writes the code." That'd have been an incomplete answer. Something else changed, and I took a while to see it.

Super Saiyan: the monorepo and the three frontends

The second month started when I duplicated code. Two frontends, same blog, two copies of the component. I solved it with a monorepo. And there my role shifted.

When three apps share packages, when a change in packages/blog-ui impacts three builds, when an architectural decision propagates across twenty files — "I drive, you implement" stops working well. You have to think in systems, not features.

I learned that month that the difference between a dev who uses Claude well and one who uses it okay isn't prompt speed — it's the clarity of the mental model they hand the model. If you can describe your architecture in five sentences, Claude follows it. If you only have it in your head, Claude proposes six different things and two of them clash.

The central skill shifted from "knowing code" to "knowing how to translate a system intent into a conversation a model can execute."

Super Saiyan 2: discipline as infrastructure

Third month brought a scare. We did a big refactor. Three apps changing at once. Claude executed it perfectly — the commits were good, the tests passed, the deploy worked. A week later we found out we'd dropped a security check on two critical routes. Not by carelessness — by trust.

That week I understood something I've repeated since: when you let an agent execute, your guardrails have to be mechanical, not social. A human notices unsafe code by reading it. An agent doesn't. A human notices a missing test. An agent only does if you ask it to.

The blog has 247 automated tests. I didn't write them just because — I wrote them because every time something broke in production, the pattern was "Claude did it well except in this case that wasn't covered." Tests are the safety net that lets you keep moving fast without quality collapsing.

Strict RLS in the database. E2E login test. Custom lint rule for cross-subdomain cookies. Brand reviewer validating every AI generation. Each one is a commitment to my future self: "if you trust this point too much, this is what'll stop it before it reaches production."

Super Saiyan 3: engineer at moments, copywriter at others

Fourth and fifth months were strange. I started doing things engineers don't usually do.

Writing BRAND.md. Deciding Agentikas's tone. Designing the design system in markdown. Thinking how the brand voice feels coming out on LinkedIn vs. on X. Tweaking prompts so Claude doesn't say "digital transformation" because I hate that phrase. Writing home-page copy I'm rewriting right now.

Someone else used to do this. In a bigger team, they still would. But the reality of building solo with a model — at five-person team velocity — is that many roles collapse into one. The engineer just writing code stops being enough. You have to write the rules the model will follow: to write, to review, to design, to publish.

And that's tiring in a different way. Fatigue isn't physical — it's context-switching. Going from "design the queue worker's endpoint" to "write the subtitle of this post for LinkedIn" in fifteen minutes makes you change brains. The one writing TypeScript isn't the one deciding whether a sentence sounds too corporate.

What doesn't look like Goku

The transformation metaphor has a limit. Goku transformed to fight. I don't fight — I build. Super Saiyan strength isn't "working more hours" — it's new capacities I didn't have before. Knowing how to use Anthropic's API well. Knowing which prompt-cache patterns make a sustainable bill. Knowing when an E2E test is necessary and when it's overhead. Knowing how to let the model write while I think about the next thing.

And, above all, the new strength I most struggled to acquire: knowing what NOT to automate. Voice, taste, decisions that need human context. I don't delegate that to the model. I do it slowly, reading myself out loud quietly before hitting publish.

The next level

Goku after Super Saiyan 3 goes Super Saiyan God, then Super Saiyan Blue, then Ultra Instinct. Each is an order of magnitude harder and weirder to maintain. The metaphor breaks there — I don't think there's an order of magnitude beyond where we are. But I do think there's a pending transformation, and it's the one that lands when you stop being just you building with one agent and start coordinating multiple agents coordinating with each other.

That's not vibe coding anymore. It's something else. And if the next six months are half as strange as the past six, I'll have things to write about.

Meanwhile, this post is publishing on agentikas.blog.agentikas.ai, in Spanish and English, on LinkedIn and X, with an Unsplash cover image, with schema.org in the HTML and a WebMCP manifest at /.well-known/mcp.json. Everything described in the previous posts, executing right now, without me touching anything after I hit publish.

That's the new strength. It isn't magic — it's discipline, infrastructure, and a good model. But sometimes, when I see it work, it looks a little like magic.

---

Agentikas is open source. If you want to see the code I'm describing — from the first commit to this post — it's in github.com/agentikas/agentikas-blog. And if you fancy building something like this, my LinkedIn DMs are open.