A few days ago I came across a very interesting stream where someone showed their setup for agentic programming using Claude Code. After years developing “the old-fashioned way,” I have to admit that I’ve found this revealing.
What is Agentic Programming?
For those not familiar with the term, agentic programming is basically letting an AI agent (in this case Claude) write code for you. But I’m not talking about asking it to generate a snippet, but giving it full access to your system so it can read, write, execute, and debug code autonomously.
Yes, this includes giving it write permissions on your filesystem. Before you run away, keep reading.
The Setup That Caught My Attention
The developer in the stream had set up a very smart configuration:
The Heart: claude.md and Makefiles
Instead of giving instructions to the air, they had created a claude.md file that acts as an instruction manual for the agent. There they document:
- What commands to use:
make devto start services,make tail-logto view logs, etc. - What NOT to do: “Never stop the server” appears several times
- Where things are: log paths, project structure, etc.
What I find brilliant is that they use Makefiles as a single entry point. Everything goes through make something, giving the agent a limited but powerful set of tools.
Unified Logging: The Key to Success
Here’s the trick I liked most. Instead of having scattered logs, they had configured everything so that both the frontend (Vite) and backend (Go) wrote to the same log file using a tool called shoreman (a foreman fork).
Why is this brilliant? Because when Claude encounters an error, it can run make tail-log and see exactly what’s happening, both in frontend and backend, all in context.
Auto-reload and Hot-recompiling
The setup included auto-reload for the frontend and watchexec to automatically recompile the Go backend. This means Claude can make changes and immediately see if they work, without manually restarting services.
What Works (and What Doesn’t)
The Good Stuff:
- Go is perfect for this: Go’s verbosity with error handling (
if err != nil return err) turns out to be ideal for agents. The code is very explicit and easy to understand. - Test data generation: Claude is excellent at creating realistic test content. In the stream, it generated forum conversations that looked authentic.
- Automatic debugging: When something fails, Claude can read the logs and self-diagnose. It’s impressive to see it in action.
The Limitations:
- Tests are a disaster: Claude doesn’t understand how to write good tests. The developer tried to configure a testing system with rollbacks and Claude produced terrible code.
- Context degrades: The more code in context, the worse the quality of what it generates.
- Frontend is more complicated: Although it worked, the frontend code it generated was more “sloppy” than the backend.
Costs and Practical Considerations
The guy mentioned that with the $100/month Claude subscription (only using Sonnet), he doesn’t reach the limits working with one agent at a time. With $200/month he says it’s practically impossible to hit the limit.
He also uses “yolo mode” (--dangerously-skip-permissions) which basically gives the agent carte blanche to do whatever it wants. Controversial, but effective.
My Personal Take
After seeing this in action, I think agentic programming is at a very interesting point. It’s not going to replace the programmer, but it can radically change how we work.
What seems key to me is that your project’s architecture matters more than ever. If you have a well-structured project with clear commands and proper logging, Claude can be incredibly productive. If your project is a mess… well, Claude will be chaotic too.
I also think that languages like Go, which prioritize clarity over elegance, will shine in this context. The verbosity we sometimes criticize turns out to be an advantage when an AI agent has to understand what’s going on.
To Try at Home
If you want to experiment, these are the key points:
- Start small: A simple project with clear structure
- Document everything: Make a
claude.mdwith clear instructions - Unify logs: Have everything go to the same place
- Automate auto-reload: Fast feedback cycles
- Use Makefiles: A clear entry point for commands
And remember: never compact the context. If Claude runs out of context, better start a new session with a summary.
Final Reflection
Are we moving toward a future where programming is more directing than writing? Maybe. What’s clear is that tools like Claude are changing the game.
I, who have almost 30 years in this and still prefer paper and colored pens for planning, have to admit this has intrigued me. I don’t know if I’ll change my workflow overnight, but I’ll certainly experiment.
What do you think? Have you tried agentic programming? I’d love to hear your experiences.
The original stream is available on YouTube. Worth watching in full if you’re interested in the topic.