The Agentic Era: How Claude Can Make You a 10x Engineer on the Side

Hey folks,

I have done so many things across the past few months with Claude, all on my free time. It really shows how great stuff can be done with AI when you have an idea of what you’d like to do. From experimentations and POCs, to side projects that evolved into real production-grade SaaS, but also debugging, system administration, security hardening, observability and so on. Depending on the amount of work and the technical interest, I might make a full article on some of these further down the road.

Discovering Claude

It all started with very simple tools. I’m a freelancer, and on my previous contract we had a platform where both parties signed the CRA (Compte Rendu d’Activite), an activity report to justify the monthly bill. The billing part I had to do every month myself. Most of the info on a bill is pretty much the same every month, so that was definitely something I could automate.

This is one of the first things I did with Claude, a freelance document generator. A simple CLI written in TypeScript using Bun where you set a config (stuff that never changes) and the CLI asks you a couple of questions: which days you did not work this month, which days you half-worked. It knows bank holidays, potential off days, your rate. Then it generates your billing with VAT calculation and the CRA, both as separate PDFs and a combined one. Simple, useful, done in an afternoon.

Around the same time, I also built Qobuz Suggest, a pipeline orchestrated through n8n that fixes Qobuz’s terrible music recommendations. It fetches my listening data, uses Last.fm for discovery, Claude AI for smart curation, and pushes tailored playlists directly into my Qobuz account on a weekly basis. I wrote a full article about it, but the point here is the same: Claude turned a frustration into a working solution in an evening. Something I’d been thinking about doing “someday” was suddenly done.

Going Bigger: Varsafe

Then over time I started bigger and bigger projects, up until the SaaS I’ve always thought about creating but never managed to get the time to go through until completion. Varsafe is a secrets management platform. Think vaults, team collaboration, API tokens, secure rotation. Multi-tenant, production-grade.

I started crafting the architecture, designing the domain, reducing scope as much as possible for an MVP. At the beginning you go super fast, but when you go through the entire process you start seeing all the things that need to be done to make a project from start to finish. To me the hardest part is the last mile. You’ve completed 90% of the project but there’s a ton of small details and things you want to tackle before going live.

I tried during the process to be local-first as much as possible, pretty much anything can run locally. But I pushed to go live even if I was not done, as early as possible, to confront the product with the complexity of deploying software for real. Even if everything is dockerized locally, deploying your project is another chapter in your solopreneur builder journey and this comes with a lot of other concerns: security, server management, resource management, threats, and so on. Opening your service partially, allowlisting IPs, showing an invite form, making sure it all works end to end.

The tech stack tells the story of the ambition. Today Varsafe is live and I’m proud of the product I’ve created. And I’m dogfooding it heavily: all secret management for my deployments and CI pipelines goes through Varsafe itself. Nothing like being your own user to find the rough edges.

The Infrastructure Rabbit Hole

Then after a couple of weeks on Varsafe, I had a base working product but the hard part was starting: infrastructure, deployments, CI/CD.

The evolution went like this:

Deployment scripts. Started with a homemade deploy script that grew substantially over time. It was a blue-green deployment script written in TypeScript with Bun, interacting with Docker. My guardrail was Claude. This implied Caddy as reverse proxy at first, then switched to Traefik. Varsafe runs on a single PostgreSQL + a single Redis. Simple, but the deployment orchestration around it was not.

Code hosting. I went through three iterations:

• GitHub first, with my own runners
• Then Codeberg, I wanted to go full EU-hosted, but the UI/UX and runner situation didn’t work for me
• Finally self-hosted GitLab with my own runners

Every single one of these setups (GitHub Actions runners, GitLab runners, CI pipelines) was handled with Claude as my infra companion.

The limits of handmade scripts. When I started Glowo and did a similar deployment setup, I started seeing the limits. I had a couple of options:

• Coolify, decent but not customizable enough for my needs
• Dokploy, similar story
• Hybrid Vercel/Netlify + server, possible but fragmented
• Clever Cloud / Koyeb, PaaS options for EU hosting

But I chose Hetzner for VPS hosting and Scaleway for infra (S3, Docker registries). Claude helped me build comparison grids of cost vs. performance across providers.

K3s. I ended up going with k3s, an in-between solution between full Kubernetes (overkill for my scale) and managing Docker by hand. My needs were simple: zero-downtime deployments, health checks, no blips. Claude helped me achieve all of that, and then I brought the same setup to Varsafe.

Watchlab. Over time, the infra management itself became a project: Watchlab, my infrastructure-as-code setup with Authelia for SSO, Crowdsec for threat detection, HAProxy for load balancing, Traefik for routing, and a full Grafana + Loki + Alloy observability stack. All orchestrated through GitLab CI, all built and maintained with Claude.

Glowo: The Monitoring Platform

After Varsafe I started Glowo, an uptime monitoring and status page platform. If Varsafe taught me how to build a SaaS from scratch, Glowo taught me how to build a complex one. Monitors, real-time dashboards, notification channels, multi-region status aggregation, incident management, Stripe billing.

This is where Claude really shined on the backend side. At one point my dashboard was loading slowly. Claude diagnosed 11 N+1 query patterns, reduced 256 queries to 4 on the main endpoint, extracted a reusable utility, and pushed a 26-file change, all in one session. That’s the kind of thing that would take a developer a full day of profiling and refactoring. With Claude, I described the symptom, it found the root causes, and fixed them.

The domain modeling got sophisticated too: state machines for monitor pause/resume, per-region heartbeats as append-only records, tiered caching (L1 in-memory + L2 Valkey), and database constraints for concurrency safety. All of this with Claude as co-architect, challenging my decisions, proposing alternatives, and implementing the agreed-upon approach.

Same as Varsafe, I’m dogfooding Glowo: all the infrastructure I deploy, Varsafe included, is monitored through Glowo. This creates a really nice feedback loop. I use the product daily, I spot UX issues or missing features in real conditions, and I improve the service iteratively. Dogfooding both products at the same time means every deployment touches the full chain: secrets from Varsafe, monitoring from Glowo.

Everything Else I Built

What surprised me looking back is the sheer variety. Beyond the two main SaaS projects, I built or experimented with a lot of things:

Yhtua, a Tauri 2-based 2FA authenticator app (Authy spelled backwards). I already wrote about the genesis, but Claude helped me push it way beyond the initial version. Over 6 releases up to v2.6.0: AES-256-GCM encryption at rest with the ring crate, PBKDF2-SHA256 key derivation (600k iterations), encrypted cloud sync via any folder (Dropbox, Drive, OneDrive), HMAC-SHA256 backup integrity, auto-clear clipboard after 500ms, AppImage/deb/rpm/dmg/msi builds. The stack is Nuxt 4 + Vue 3 on the frontend, Rust on the backend. Claude was instrumental in getting the crypto layer right.

NexRouter, a modern OpenWrt router management platform to replace the dated LuCI interface. Written in Go (Gin + WebSocket) with a web frontend, it manages networking, WireGuard/Tailscale/NetBird VPNs with kill switch, firewall rules, connected devices, and real-time system monitoring, all running locally on the router. The goal is to open-source it as a UI dashboard alternative usable on GL.iNet or any other OpenWrt-based router. Still a viable POC that I’m testing and improving at home on a real router when I have free time, with some space challenges since it has to run on constrained hardware. The kind of project where Claude’s ability to handle both Go backend and frontend in the same session really shines.

Landing pages & small sites, a couple of landing pages here and there (Astro, Next.js + Supabase), each one done in a fraction of the time it would have taken manually.

Sozet-Chat, a POC for a decentralized messenger combining Tezos blockchain identity with the Nostr protocol for message transport. Still a work in progress, but a fun exploration of E2E encryption and WebSocket signaling with Claude handling a good chunk of the crypto plumbing.

Tradebot, a POC/experimentation for an autonomous Polymarket paper trading bot. Abandoned now, but it was a fun exercise: Kelly Criterion for position sizing, SQLite for trade history, real-time WebSocket price feeds. The meta part was that the bot wrote performance reports to JSON, designed to be fed back to Claude for strategy evolution.

Rondpoint, a POC for a Traefik dashboard to manage routes, set ACLs, and so on. NestJS + SQLite + React. No longer used, but it was a good experimentation to see how far I could go building a full-stack admin tool with Claude.

Looking at this list, what strikes me is that everything I built or experimented with has proper architecture, tests, and for the ones that made it, they deploy to real infrastructure.

Building Like a Power User

The other part of this journey is learning to work with Claude efficiently and consistently as the codebase grows. You may have a clear idea about what you’re building, you may know which tech you’d like to pick, but along the road many things will challenge that. You find out that some technologies are not relevant anymore, some features can wait for post-MVP, and you’re constantly tempted to add new ideas.

My guide was to keep the product as minimal as possible and well done. Hexagonal architecture, maximum testability, clean code. But the real lever was something else entirely.

The CLAUDE.md: Your Engineering Playbook

My global CLAUDE.md is over 500 lines. It encodes everything I care about as an engineer: hexagonal architecture with domain/ports/adapters, abstract classes as port contracts for dependency injection, rich immutable entities with private constructors and factory methods (create(), fromProps()), in-memory fakes for every repository (no mocks, ever), behavior-driven testing, domain events collected by entities, transactional outbox pattern, branded types to prevent ID swapping across tenants, multi-tenant data isolation, Zod validation at boundaries, and type safety from start to finish.

This file didn’t start at 500 lines. It grew organically, one lesson at a time. Every time Claude made a choice that challenged what I was used to, every time I found a pattern that worked well, every time I caught a bug that could have been prevented, I added a rule. It’s the accumulation of hundreds of sessions of working together.

The result: Claude doesn’t just write code for me, it writes code the way I want it written. When it creates a new entity, it follows the immutable class pattern with create(), fromProps(), pendingEvents, and version. When it writes a repository, it scopes by tenant and uses optimistic locking. When it writes a test, it uses in-memory fakes, never mocks.

This is the real unlock of agentic coding: teaching the AI your standards once, and having it apply them forever.

Custom Skills and Automation

Beyond the CLAUDE.md, I built custom skills, reusable prompts that Claude can execute. A /fix-ci skill that investigates failing GitLab pipelines, diagnoses failures from job logs, fixes the code, pushes, and monitors until green. A /deploy skill that triggers CI pipelines for specific services. An /update-deps skill that handles dependency updates across my entire monorepo, 80+ packages with major version bumps, fixing breaking changes, and pushing with all tests passing.

Multi-Clauding

One thing I didn’t fully realize until I looked at the usage data: I run multiple Claude sessions in parallel. One session fixing a CI pipeline while another implements a feature. One session debugging infrastructure while another refactors a domain model. This is a workflow that simply doesn’t exist without AI. You can’t pair-program with two humans simultaneously on different problems.

The Numbers

Let me put some numbers on this. Over a single month:

Mostly evening and night sessions, that’s when the side projects happen (reminds me of Swizec Teller’s Why Programmers Work at Night). Primarily TypeScript, but also YAML, Go, Markdown, Shell.

That’s not a toy. That’s the output of a small engineering team.

When It Goes Wrong

I’d be dishonest if I painted this as a flawless experience. It’s not all sunshine. Here’s what the rough parts look like in practice.

Misdiagnosed root causes. This happens mostly because I’m used to letting Claude continue working when I go to bed, using --dangerously-skip-permissions through huge plans or long debugging sessions. It became common over time. Without me there to course-correct, it can go down the wrong path for a while. For instance, I was investigating why my Tezos baker rewards weren’t coming in. Claude went down a port-forwarding rabbit hole, debugging network configs, checking firewall rules, testing connectivity. I had to push back myself when I realized the actual cause: the DAL node had simply been down for 5 days. Another time, resetting an Uptime Kuma password led to extensive network debugging as a red herring, when the real problem was corrupt JSON in the database crashing the app on login.

Cascading infrastructure outages. During a CI pipeline debugging session, Claude force-removed a running Traefik container. That took down my self-hosted GitLab instance entirely and left the pipeline still broken. During a security hardening session across 6 servers I manage (VPS, dedicated, NUC at home), aggressive changes caused a major outage, 32+ Glowo monitors went down, requiring extensive recovery work to get all monitors back up.

Multi-iteration fixes. Dependency updates across the monorepo sometimes required multiple rounds. Biome auto-fix broke Vue templates, Bun bundler needed NestJS externals configured, image-size v2 API changes took several attempts. An auth context change needed 3 separate pipeline runs before correctly aligning formats.

That said, Claude is also perfectly capable of recognizing when it’s going down the wrong path and self-correcting to achieve the result by the end of the session. Most of the time it gets there. But when it touches production infrastructure, being aware of what’s happening and stepping in when needed is still important. For instance, when doing SSH hardening I always make sure Claude tests the new configuration before throwing the keys, so neither of us gets locked out of the server.

All in All

That’s not the entire story, there’s so much more to say about what I’ve been building over the past few months. I might do a dedicated Varsafe or Glowo article when I have the motivation to go into all of the details.

What I can say is that Claude worked like an amazing companion in every aspect of the process, and will probably continue to over the next months and years. To build a product, production-grade, today you need to cover:

• Backend: domain modeling, APIs, database design, testing
• Frontend: UI/UX, responsive design, accessibility, performance
• Infrastructure: Docker, k3s, reverse proxies, CI/CD pipelines
• Server administration: SSH, debugging, disk management, process management
• Security: firewall hardening, SSO, secret management, threat detection
• Observability: Glowo, Grafana, Loki, Alloy, alerting
• SEO & Marketing: landing pages, meta tags, social sharing
• Design: theming, layout, animations, dark mode

That’s a lot of hats. The good thing is, when you’re motivated, you can definitely do all of this with Claude. You won’t get all of that in a single prompt. You’ll probably have to know a little bit of what you’re doing. I’m not saying you can blindly build such complicated services with your eyes closed. But if there are areas which are not necessarily your domain of expertise, you’ll be able to build a decent chunk of it that’s near production-grade, or even production-grade if you iterate enough and are picky about the details.

Because all in all, this is what matters to me. I knew my backend, I knew my architecture, but what always drove my iterations was the UX, the end user using the product. That’s what drove most of my work over time.

Today, Varsafe is live and Glowo is now the one I focus on, my main side project with plenty of work ahead. I keep experimenting with new ideas whenever I find the time. The tools have changed, but the drive hasn’t. I just ship a lot more now.

Even this blog and the article you’re reading right now were built with Claude.