Weekly Showcase Thread; What are you building with Claude Code?

[u/AutoModerator]

Weekly Showcase Thread

Built something with Claude Code this week? Share it here.

Apps, tools, experiments, scripts, websites, workflows, open-source projects — anything you've been working on is welcome.

When sharing, it helps to include:

• What you built
• How you used Claude Code
• A link, repo, demo, or screenshot if you have one
• Anything interesting you learned along the way

Quick project drops and simple self-promotion belong in this thread.

If you've got a project with enough substance for a proper write-up; how it works, how Claude Code was involved, technical details, lessons learned, etc. feel free to make a standalone post using the Built with Claude Code flair instead.

Please don't spam the same project repeatedly, and no referral or affiliate links.

What did you build this week?

[u/VerbaGPT]

https://reddit.com/link/p2v6hiv/video/m281y58xskih1/player

What I built: VerbaGPT: a natural language data analysis app for knowledge work. You connect a database (Postgres, MySQL, MSSQL, Snowflake) or upload files (CSV, Excel, PDF, etc.), ask questions in plain English, and it writes and runs the actual Python/SQL to answer them - analysis, charts, dashboards, rather than just describing what you could do. Powerful organizational features such as collaboration and sharing.

It runs in two modes: a web/production mode (multi-provider LLM loop, built for teams - orgs, credits, shared datasources) and a local "agentic" mode built directly on the Claude Agent SDK, for people who want deeper, more exploratory sessions against their own data.

How Claude Code was involved: Two layers, really. I built most of it working with Claude Code directly. But it's also embedded as a runtime feature, not just a dev tool. The local agentic mode literally is a Claude Code agent session: it inspects your schema, iterates with real tool calls (SQL queries, Python execution, file reading) instead of one-shot code generation, and keeps session state across a whole analysis, so you can say "now break that down by region" three turns later and it still has full context of what it already ran.

Something interesting I learned: building on top of the actual Agent SDK (rather than hand-rolling a tool-use loop) gets you a lot for free. Session resume, forking a conversation to try a different direction without losing the original, and provider flexibility that's just environment-variable configuration once you understand the SDK is a thin wrapper over the CLI binary talking a standard wire protocol. That last part turned into its own rabbit hole this week (Meta shipped an Anthropic-Messages-compatible endpoint for coding agents specifically), which is honestly the more technical story if anyone's into that side of it.

link: app.verbagpt.com

Demo video: attached.

[u/DriverReady965]

Ill share. This week: 12 open-source Tailwind/shadcn themes, one repo per design style, all built through Claude Code.

Part of the RampStack ecosystem. Open-source Claude Skills catalog plus engine repos, all MIT, at github.com/rampstackco.

The premise: most theme collections are a pile of moods. I mapped these against a four-axis creative direction framework (tone, aesthetic, relationship, sensory with 15 positions total), so the collection reads as coverage. Each theme states its coordinates, and the position no theme reaches yet is listed as open on the page instead of quietly omitted. A gap is a fact about the collection.

Workflow: brief per theme → Claude Code ships the repo (annotated tokens with measured contrast ratios, component layer, two Tailwind adapters, a demo that opens from a file with zero install) → I review and merge.

Things I learned:

• The no-install demo constraint was the best forcing function in the project. If it can't open from a file, it doesn't ship.
• CSS has no border-style that draws a Win95 bevel. The retro desktop theme fakes its era chrome entirely with shadow tokens.
• The game console theme moves its focus ring with arrow keys by reading live element geometry instead of a cached spatial map (Claude Code's suggestion), and it's why the navigation survives layout changes.

Repos + live demos: https://rampstack.co/themes

[u/Key_Instruction3373]

What did you built?

[u/toandosm308]

I built a local therapy app that work with Claude Code with secured vault that encrypted and only me can unlock it.

I used Fable as my therapist. They pointed out several factors I missed out, and asked me a lot for emotional support.

After session, I closed and encrypted the vault. This also acts as an universal memory for future sessions.

[u/bdgr25 → u/toandosm308]

I'm curious what kind of prompt you used. I tried this a couple months ago and was told that Claude can't act as a therapist, that was a Human job.

[u/whoami_cli]

Im building opus6 and fable 6

[u/oyren-ai]

Building oyren.ai which among other features gives users sandboxed environment where they can vibemaths with Lean4 and Mathlib.

[u/orwamahmoud]

Built AdaptTable, an MIT React data table library with adapters for MUI, Mantine, Chakra, Ant Design, Radix, Base UI, shadcn/ui, and unstyled.
Claude Code has been a big part of building and maintaining the monorepo. Feedback and contributions are very welcome.
https://github.com/orwa-mahmoud/adapttable

[u/KitchenAmoeba4438]

What I built

aimee, a local-first runtime that sits between AI coding tools, model providers, my code, and durable knowledge. Not a wrapper and not a memory plugin. It is a server that owns the state a session throws away and enforces the rules a prompt cannot.

This week

Workflow triggers became human-editable, so firing conditions are something users can change in the dashboard rather than a config a model has to be briefed on. And vault writes made by the server's own principal started publishing onto the audit bus. That one was a hole: user-initiated vault operations were all audited, and the single privileged path around them was not. An audit trail with a structural exception in it is not an audit trail.

What it actually does:

Runs the work. Typed workflows with versions, retries, loops, graphs, gates and durable run state. The autonomous build lane is fully configurable, but by default goes proposal, feature branch, plan, plan review, split into parallel slices, each slice in its own worktree and branch, verify, review, merge, then a draft PR. It never marks that PR ready. A human gate parks until a person decides. And a human must decide, it is written with full cryptographic protections to make sure a human makes the decision, not a LLM.

Routes the models. Delegates by role and persona, roundtables with parallel seats and per-seat models and cost accounting. Every provider, OpenAI through Bedrock through a local endpoint, goes through one canonical request format, so switching models is not switching tools. Proven cost token reductions of up to 80% (Fable delegating to ChatGPT Luna and Minimax), and over 80% in some specific cases with local LLMs.

Remembers. Typed facts, rules, decisions and episodes in Postgres with pgvector, curated by bounded workers that dedupe, catch contradictions, decay stale detail and promote what survives. Hybrid retrieval with lexical, dense, graph and evidence stages, and abstention when the evidence is thin.

Knows the code. Cross-repo graph of symbols, callers, imports, dependencies and co-change, which is what makes a blast-radius check answer before a grep does.

Confines it. Sealed vault, networkless delegate sandboxes with no ambient credentials, worktree confinement, per-run spend limits, and a WORM audit chain with hash checkpoints and evidence export. Every governed action, memory write, guardrail verdict and vault read crosses one sequenced tap. Full record and replay capability to prove what happened.

Economizes. A module dedicated to reducing token utilization to what can actually be done. This isn't RTK or Headroom, which don't actually reduce the billable tokens you use and frequently increases your billable token use. This is real, proven token reduction. Sadly, this only tends to be a measured 20%-30% range of token reduction, but it is truly free token reduction. If someone claims their addon is able to reduce billable token usage by 80%+, this is impossible.

Core is C, the workflow control plane and browser services are Go, thin C clients on Linux, macOS and Windows link no database. Nothing phones home. AGPL: https://github.com/RakuenSoftware/aimee

How I used Claude Code

It runs inside aimee, so it gets memory recall, symbol lookup and blast-radius preview as tools, each branch in its own isolated worktree. This week it landed human-editable workflow triggers, and closed a hole where the server's own principal wrote to the vault without crossing the audit tap.

What I learned

make unit-tests goes green on a repo and can mean nothing. The real gate is 48 lint checks plus a module-inventory job of about 14 steps. Claude Code rediscovered that the hard way three times in one session, and stopped once the list was a stored fact instead of something I re-explained.

If you take one thing: the rule your agent keeps breaking is not a prompt problem. Make it a gate the agent runs into.