Intranets Today

Claude + Vibe Coding: My Week In The Trenches

Quick outline

  • What I used and why
  • Real prompts and fixes Claude gave me
  • What worked, what broke, and my final take

Why I even tried this

I like fast web backends. I also like trying weird stacks on quiet Sundays. So I spent a week building a tiny API with vibe.d (the D language web framework) while pairing with Claude. (Quick sidebar: the framework lives on its official site, and Claude itself is built by the team at Anthropic.) Coffee, lo-fi beats, and way too many sticky notes. You know what? It felt good.
If you want an expanded journal of that exact seven-day sprint, check out my blow-by-blow week in the trenches write-up.

I’ll be straight. I thought Claude would choke on D. It didn’t. Well… not always.

My setup (nothing fancy)

  • MacBook Air M2
  • DMD and DUB installed
  • A fresh folder named vibe-play
  • Claude Desktop on Mac (for chat and Artifacts)
  • Terminal and VS Code (standard theme because my eyes needed mercy)

What I built, for real

I made a tiny JSON API with one route, then added another route with a query param, and a super small HTML page.

Here’s the first server Claude helped me shape:

import vibe.core.core;
import vibe.http.server;
import vibe.http.router;
import vibe.data.json;

void hello(HTTPServerRequest req, HTTPServerResponse res) {
    res.writeJsonBody(["message": "hi"]);
}

void main() {
    auto router = new URLRouter;
    router.get("/hello", &hello);

    auto settings = new HTTPServerSettings;
    settings.port = 8080;

    listenHTTP(settings, router);
    runApplication();
}

My DUB file looked like this:

{
  "name": "vibe-play",
  "targetType": "executable",
  "dependencies": {
    "vibe-d": "*"
  }
}

Run steps I used:

  • dub init vibe-play vibe.d
  • dub run

Then I hit it:

Fist pump moment. Small, but still.

Next, I asked Claude for a route with a greeting. It gave me this, and it worked:

router.get("/greet", (req, res) {
    auto name = req.query.get("name", "friend");
    res.writeJsonBody(["greet": "hey " ~ name]);
});

curl "http://localhost:8080/greet?name=Kayla" gave me {"greet":"hey Kayla"}. Cute.

Real prompts I used (and what I got back)

  • Me: “I’m getting module not found: vibe.http.router.”

    • Claude: “Add vibe-d to DUB and run dub. Also check import paths.” It even showed the exact import lines to keep.

  • Me: “Server starts, but nothing responds. It just hangs.”

    • Claude: “You likely skipped runApplication(). Add it after listenHTTP.” Yep. That was it.

  • Me: “JSON looks weird. How do I return a clean body?”

    • Claude: “Use res.writeJsonBody and pass an associative array.” That fixed my messy string output.

  • Me: “I need a tiny HTML test page.”

    • Claude used Artifacts to render a quick static page. I copied it into index.html and tested it in the browser. The page looked simple and clean.

Here’s the tiny page it gave me:

<!doctype html>
<html>
  <body>
    <h1>Test Page</h1>
    <button id="btn">Say hi</button>
    <pre id="out"></pre>
    <script>
      document.getElementById('btn').onclick = async () => {
        const res = await fetch('http://localhost:8080/hello');
        document.getElementById('out').textContent = await res.text();
      };
    </script>
  </body>
</html>

I opened it, tapped the button, and saw the JSON. Simple joy.
There’s also a longer breakdown with copied-and-pasted snippets in this hands-on vibe coding guide.

The wins (and they felt real)

  • Fast fixes for DUB and imports. I pasted errors. Claude gave short steps. Not walls of text.
  • Clean route examples. The code ran. No magic, just solid patterns.
  • Gentle refs to gotchas. It reminded me to call runApplication() more than once.
  • Good at “small ask, small answer.” I kept prompts short. Claude kept replies tight.

For an even deeper dive into the small tooling tricks that actually keep you in flow, my personal take is collected over here.

The rough parts (still worth it)

  • Old API names sneaked in. Once, it suggested a call that vibe.d changed ages ago. I pointed out the compile error. Claude corrected itself fast.
  • Guessy version advice. It tried to suggest a specific vibe-d version. My fix? I asked for “latest stable via DUB” instead. That kept it clean.
  • State confusion. Over a long chat, it forgot a minor choice I made. I moved that choice into the prompt each time. Problem solved.

Keeping that lovable vibe while still shipping code is harder than it looks—this short reflection captures the tension pretty well.

Day-to-day feel

It felt like pairing with a calm junior dev who reads docs faster than me. I still drove. Claude watched the road. It flagged things I missed, and it wrote decent first drafts.

While we were jotting helper functions named sugarWrap() (pure syntactic sugar, pun fully intended), a teammate jokingly asked if I’d ever looked into how the word “sugar” shows up in non-coding contexts. That curiosity detour led me to this clear, legal-minded explainer on whether modern “sugar” arrangements cross any red lines: Is Being a Sugar Baby Illegal? — the piece walks through state-by-state rules, common myths, and practical considerations, so you can satisfy your etymology itch without falling down an endless search-engine rabbit hole. On a related tangent, I needed a real-world set of user-generated listings to stress-test my JSON parsing; checking how modern personals boards lay out their posts was perfect research, and the Doublelist feed for North Carolina’s Gastonia area made a surprisingly tidy case study: Doublelist Gastonia page — skimming it lets you see live listing titles, timestamps, and anti-spam conventions in action, giving you a ready-made data pattern you can mimic for mock APIs or sample datasets.

A few tips that helped me

  • Keep prompts short and clear. “Add a /greet route with a name param.”
  • Paste the exact error. Don’t paraphrase.
  • Ask for “run steps” after big changes.
  • Save the working snippet in a note. Copy/paste beats memory.
  • When Claude guesses, ask it to “use current docs” or “stick to vibe.d stable patterns.”

Final take

Would I use Claude again for vibe.d work? Yep. It made the small stuff easy, and it kept me moving. It’s not perfect. It pulled an old import once. It also rambled when I asked open questions.

But for hands-on coding, the vibe was right. Light, fast, and helpful. I also compared notes with an earlier class write-up on how it actually felt, which you can skim right here.

zielkeguptill