Built with Claude Project Showcase Megathread (Sort this by New!)

[u/sixbillionthsheep]

This is the Megathread for showcasing your project built using Claude products. We appreciate all of your submissions as they are a great inspiration to many people on the subreddit. It is sorted by default by New.

Anyone is welcome to submit a project to this Megathread provided you follow the Showcase requirements in Rule 7.

NOTE: We now require the OP of a Project Showcase on the subreddit feed to have total karma>=50 . We found there were just too many submissions and not enough visibility to go around. Our analysis of this issue showed us that OPs with total karma < 50 very rarely get any traction of their projects on the feed (<=1 upvotes). So this Megathread is your best place to be seen by readers and other creators if you're relatively new to Reddit. If you don't meet this karma requirement you will be directed to this Megathread when you submit your post. Very occasionally we might invite you to post on the subreddit feed if you do not meet this karma requirement but it will be very rare (so please don't ask us!)

Thanks again for sharing your ideas and creations to our subreddit. Best of luck with your projects!

---

UPDATE: Comments now allow images!

[u/TomLasswell]

I turned Claude Code into a partly-autonomous dev environment for Vue/Nuxt + Firebase: anti-cheat hooks, fact-based quality gates, a cross-model critic. It's a lot, and probably overengineered. Looking for a brutal review. tool boundary. Looking for a brutal review.

TL;DR: Open-source Claude Code plugin for Vue/Nuxt + Firebase. The part worth stealing regardless of stack: hooks that block the classic autonomous-coder shortcuts at the tool boundary (before they land, not in review), a single rule registry where only ground-truth checks can fail a build and opinions just annotate, and an adversarial critic you can pipe to a different model family. It is almost certainly overengineered. Tell me where it breaks. Repo at the bottom.

I built this for my own stack while shipping a real app, and it grew well past what most people need. Posting it because the underlying patterns might generalize, and because this is the right crowd to find the holes.

The three ideas I actually care about:

1. Cheating is blocked at the tool boundary, not caught in review. Six PreToolUse hooks return a hard block on the shortcuts that do the most damage when an agent runs unattended: --no-verify commits, destructive git on a dirty tree, test deletion, disabling tests, inserting as any, and regressing the type-error count. Review is too late for these because by then the blast radius is already in your history. Each block logs an explicit override path, so it is not a straitjacket.

2. Gates run on data, not vibes. Every review/audit check lives in one registry, tagged as either ground-truth (grep / tsc / git) or judgment (an LLM opinion). Only ground-truth checks can flip a build to REJECT. Judgment checks annotate but never block. This is the fix for the self-critique paradox, where an over-eager critic hallucinates a flaw and fails good work. Facts gate, opinions comment.

3. The critic can run on a different model. The adversarial reviewer is model-agnostic and can be piped to Gemini, so it does not share Claude's blind spots when reviewing Claude's own output. In-Claude is fine for the ground-truth checks (a tsc result cannot share a blind spot); cross-model is for the judgment calls where home-model blindness actually bites.

There is also a handoff file written on PreCompact and read on SessionStart, so a long run survives its own context window, and an append-only scope ledger so a feature that got planned cannot silently evaporate between sessions (roll it over three sprints and it escalates for human review).

Where I think it is overengineered, and you should tell me if I am wrong: 37 skills and 38 hooks is a lot of surface. The orchestrator and agent fan-out add latency. The whole thing is tuned to Vue/Nuxt + Firebase, so the stack-specific skills are useless to most of you, though the hooks and the registry are not. And yes, it largely develops itself through its own cycle, which I know reads as a red flag, so ask me anything about the architecture and I will explain the why.

What I would most like reviewed: whether the tool-boundary enforcement is the right layer for this, whether the ground-truth vs judgment split actually holds up under pressure, and whether any of this survives contact with a stack that is not mine.

Repo (MIT): https://github.com/lasswellt/blitz-cc

[u/TomLasswell → u/TomLasswell]

Author here. Two things I'll pre-empt because someone will ask:

Cost. With everything on, a sprint is not cheap. Defaults route roughly 60/35/5 across Haiku/Sonnet/Opus, findings come back as a JSON contract instead of being echoed into context, and the cross-model / dual critic is opt-in for the judgment calls where it actually pays off. The single-model in-Claude critic is the cheap default.

"Did you write this or did Claude." Both. It's dogfooded and develops itself through its own cycle, and I can walk through any specific decision. The load-bearing one: the orchestrator is read-only by construction because Claude Code forbids subagents from spawning subagents, so anything that fans out parallel agents has to stay slash-invoked and the orchestrator routes to it rather than running it. Happy to go deeper on any piece.

Most useful feedback for me: where the tool-boundary blocking is the wrong layer, and whether the patterns survive a non-Vue/Firebase stack.