How I Build

Vibe Coding vs. Agentic Coding

The homepage says vibe coder. That's where I started, and the name stuck. Here's the honest fine print — because the two get thrown together a lot, and they're not the same thing.

The Loop

My setup: Claude Code as the agent, and GSD on top — originally “Get Shit Done”, today GSD Core. GSD forces structure: every phase of a project goes through the same loop, decisions and plans live as files in the repo, and the heavy lifting runs in fresh sub-agents so the AI doesn't slowly get dumber as its memory fills up.

1. 00
   Ideame

   Every project starts with a real problem — mine, or someone's I know. No AI involved. A truck cab, 6am, coffee, and a “wouldn't it be nice if…”.

2. 01
   Discuss/gsd-discuss-phaseme + agent

   Before a single line of code: what exactly are we building, what's out of scope, which decisions are mine to make. The agent asks the annoying questions, I answer them. Result: a written context file the whole phase builds on.

3. 02
   Plan/gsd-plan-phaseagentme: approve

   The agent researches and breaks the phase into small plans, each one sized to fit a fresh context. I read them and push back where they're wrong. No plan, no code.

4. 03
   Execute/gsd-execute-phaseagent

   Now the agent codes — in parallel waves, clean context per plan, one atomic git commit per task. This is the part people picture when they hear “AI coding”. It's maybe a third of the actual work.

5. 04
   Verify/gsd-verify-workme

   I walk through what was built, click through it, try to break it. Whatever fails becomes a fix plan. Nothing is “done” just because the agent says so.

6. 05
   Ship/gsd-shipme + agent

   Pull request, review, merge, release through Jenni. Then it runs on my own installs first — for weeks, not days. Then the next phase. Ships when done.

What It Looks Like

A condensed replay of how one feature comes together — the weather log in Schneespur. Real workflow, shortened and simplified output. green is me, grey is the agent.

Who Does What

Where it goes wrong

The AI is sometimes confidently wrong. It overbuilds. It forgets what we decided yesterday. That's not a reason to avoid it — it's the reason for the loop: decisions on disk, fresh context for every task, a human who verifies, and a long testing phase on my own installs.

I'm not a trained programmer. So I don't trust code because it looks right. I trust it because it ran.

• Two serious findings in my own app. I had a second AI agent attack Schneespur — seven findings, two of them bad. All fixed, all published. The pentest story →
• A month of wasted API calls. A broken n8n workflow quietly re-asked OpenAI every few minutes; the dashboard showed it, I didn't look. Monitoring has been non-negotiable since. My biggest fail →

Got an Idea?

Here's the thing: you don't have to learn any of this. If you've got an idea for a tool — something that bugs you at work, in your trade, your club, your town — and you don't feel like wrestling with an AI yourself: let's talk.

This isn't a services page. There's no package and no hourly rate here. I do this because it's fun, and a good idea is the best fuel there is.

What happens after you write

1. You describe the problem. Three sentences, no spec needed. I reply within a few days — evenings, remember.
2. I tell you honestly what I think. Can this be built with AI, roughly how big is it, and can it be open source? If the answer is "not with me", I'll say so and point you somewhere better.
3. We build something you can touch. A prototype, running on a real URL, usually within a few weeks. Then we decide together whether to go on.

Other ways this can go

• You want a sanity check: can this be built with AI — and roughly how?
• You're a company and want to see what agentic coding could look like for your team.
• It's something that can't be open. Fine — tell me anyway, no promises either way.

Good fit / not a fit