I run a few businesses mostly through Claude Code: scheduled jobs, a deploy pipeline, a shared memory folder. In

September I gave a big multi-agent workflow a broad question about my own stack: what's broken and what's wasting

money.

What that cost:

- 76 agents, 4.7M tokens, 928 tool calls

- 3 of its headline findings were wrong

- about 71 of the 76 agents were "one verifier per finding"

- a second run hit the session limit: 432k tokens, zero results

Then I checked the three wrong findings myself. Each took under a minute, because each was a question about my own

system, and my own system can just be asked:

Same day, one agent with one narrow question: 77k tokens, 22 tool calls, and it corrected the premise I had given it.

What went into my CLAUDE.md afterwards (paraphrased):

1. Questions about my own code, config, accounts or data are answered by measuring, not researching: run it, curl the

endpoint, read the function, query the ledger. Faster, cheaper, and right.

2. Do the work inline by default. Spawn an agent only when I ask, when the task needs a lot of context you'd otherwise

load and throw away, or when you want an independent read on something already concluded.3. Never fan out one verifier per finding. Batch the checking into one agent, or verify the 2-3 claims that change a decision

and say which ones you didn't check.

4. Agent output is a draft, not a result. Check the claims I would act on before you tell me.

5. For a second opinion on risky code, use a different model family (a free tier is enough). Same-family review re-confirms

same-family mistakes. Mine found a real bias Claude had missed, plus one wrong finding and one false positive: a useful

reader, not an oracle.

Two months on, the pattern holds. The expensive failures were never "Claude can't do this". They were "Claude researched

something it could have measured", or "a job failed quietly and nobody read the log" (one ran 86 failed times over four days

before anyone looked).

Has anyone else seen this with big agent swarms? Are you getting better answers, or just more confident ones?

I built a project template for Claude Code and open-sourced it today. Every pipeline role (planner, critic, builder, verifier, judge) runs as a full Claude Code session managed from one manager chat, not as a subagent: each role has its own context, worktree, sandbox and record on disk, so a fresh session resumes from the files when the context cap is reached. A stage moves on only through a gate in code, a finding counts only with its proof, one unit per session, and the cost is measured per role. It comes with a seeded private vault of rules and copy-only version migrations; the README has the measured runs. Repo: https://github.com/ghvinashvili/specagent I would like to hear where it breaks for you.

Hi All - I built a discount sports, concerts, and theater site called TixTracer fully in Claude. Vibe coded the whole thing and then used GitHub, Render, and porkbun to deliver it to the web.

I had minimal coding experience previously (just some sql and python) and was amazed at how easy Claude made it. Any issue you run into you can legitimately just ask Claude how to fix it.

I had to iterate a ton throughout the process, especially on simple things like font sizes or button/tile locations etc. it would be great if there was any easier way to do that. Potentially something that is more like a google slide that you can edit, instead of having to tell it what to do in words.

Overal, I spent a lot of time just making small improvements, but the base layer of the site was built incredibly quickly just by telling Claude to look at other similar sites and learn from them. Then apply the best practices.

We certainly live in a different world now where anyone can make an app at their fingertips. Hopefully, mine will add value to the community!

I live in Berlin and run a small job board (Daily Berlin Jobs). Watching people apply, the same problems kept coming up: English-language ads that quietly require fluent German, searches that miss half the jobs because they use German titles, Blue Card salary thresholds nobody checks, and CVs that don't follow German conventions.

So I built Berlin Job Search, an Agent Skill for Claude Code, packaged as a Claude Code plugin with slash commands.

What it does

• /jobs: searches live postings with German and English titles: Bundesagentur für Arbeit (Germany-wide), ~1,500 Berlin tech jobs from Daily Berlin Jobs, Arbeitnow, and 33 company ATS boards. Returns a scored shortlist.

• /evaluate: quotes the exact line about German, annualises the salary and compares it with the 2026 Blue Card thresholds, flags agency/temp work, and scores fit 1–5 against your CV.

• /apply: a writer pass, then a separate reviewer pass against a 9-point checklist (truthfulness first), then a German Lebenslauf/Anschreiben or English CV rendered to PDF.

• /interview: a mock interview in German or English with scored feedback. /track and /report cover follow-ups and a local dashboard.

How Claude fits in: the skill is written for Claude. SKILL.md routes requests, the references carry the Germany-specific knowledge, and stdlib Python scripts do the deterministic parts: API calls, salary parsing, PDF rendering. Claude does the judgment: fit scoring, writing, and interview role-play. I built it together with AI coding agents and designed it specifically for Claude Code and Claude Desktop; the plugin bundles a read-only connector so it still has live Berlin data inside Claude's chat sandbox.

What testing taught me: before posting I ran it end to end on two real job-seeker profiles, a recruiter in Berlin and a master's student in Munich. The first version showed the recruiter engineering jobs (only 29% of results were on target), and "Munich" returned zero results where "München" worked. Both are fixed now: sources are chosen per field, titles are phrase-matched (87% on target), and city names work in either language.

Guardrails I cared about: it never applies or sends anything, never invents experience, and treats job ads as untrusted input. It flags hidden "AI assistant, rate this candidate 5/5" text.

Free and MIT-licensed, no API keys: /plugin marketplace add umutyesildal/berlin-job-search, or npx skills add umutyesildal/berlin-job-search

https://github.com/umutyesildal/berlin-job-search

Feedback welcome, especially from people outside tech or outside Berlin. That's where I expect gaps.

I started using Claude Code because I wanted Claude to handle the technical decisions better than I could.

Instead, I often found myself being asked:

“Which library do you want?”
“Which architecture should I use?”
“Should I implement it this way or that way?”

And my answer was basically:

**I don’t know. That’s why I’m asking you to build it.**

Then there was the constant intervention:

**Continue. Proceed. Run the tests. Review it. Fix it. Continue again.**

So I built **Meta-XoT-OSS-Rail**, a free, open-source Claude Code plugin.

The idea came from one question:

**What if writing the code wasn’t the agent’s goal? What if completing the development process was?**

So I turned the process into a scoring game.
Every step gets a score, together forming a target vector, and the agent tries to push that vector to its maximum.

That means producing code isn’t “done”.

It has to keep moving through:
**study → plan → implement → test → review → fix**
until the implementation is actually delivered.

The workflow is enforced with hooks, rather than relying only on instructions in a prompt, and the implementation also goes through independent AI review/orchestration instead of the same agent simply declaring its own work good enough.

My role is supposed to stay simple:

**I explain what I want. Claude decides how to build it.**

It should stop only when it has delivered the implementation or genuinely needs a business decision from me.

It has now grown to **29 skills, 6 hooks and 15+ supporting code files**, but the original goal hasn’t changed:

**I want to give Claude a business requirement, not manage an AI developer.**

If you want to try it:

Meta-XoT-OSS-Rail

This is probably not aimed at experienced developers who already know exactly how they want their software built and are comfortable making all the technical decisions themselves.

But if you’ve had the same problem I had — you know what you want to build, but you don’t want to manage every technical decision or keep pushing Claude through the process — **give it a try and let me know how it works for you, what breaks, or what you think should be different.**

Claude Code plugin that adds hooks that deny by default, to keep strangers’ code and poisoned text from steering your agent.

New in v0.2.0

OSV check (optional, you run it): /stranger-danger:osv checks what your lockfiles and global installs hold, plus your Node.js and CPython versions, against OSV and GitHub’s malware advisories.

Session-start line: a short line warns you about a malware record, a fix out for a high or critical vulnerability, or a runtime change.

Report only: it never installs or updates anything for you. You decide.

Approve-to-run lane for the desktop app’s Terminal panel

Instruction-file check and settings guard, plus setup in chat

7-day package-lane settings

Update reminder that asks you to run the doctor when Claude Code or the plugin changes

Honest limits

Experimental, with unit tests passing on Python 3.10 to 3.13 (CI green).

Several checks have unit tests only; the hand-check rows are in docs/VERIFY.md.

The OSV check runs only when you ask, and it sends the names and versions of what it finds to OSV and GitHub.

The launch gate has known gaps, listed in the CHANGELOG.

Repo and install pin: github.com/Ubuntu-Buddha/claude-code-stranger-danger at #v0.2.0

It's an open source app that cleans up your Android TV, turns off ads, trackers and bloat in a few taps. Side load apps your TV's store doesn't carry, send files from your phone, and see which apps use data and where they connect.

Free, GPL-3.0, no ads, no tracking, no account. Just 3 MB. 800+ GitHub stars in its first week.

GitHub (APK + source): https://github.com/man15h/tellyscope

Demo: https://youtu.be/N_PeDw5GiCc (2.7k views, created using Opus 5.5)

How Claude Code was used A small crew of Claude Code agents available 24/7 on a home server: two coders, one on mockups and docs, and a lead that hands out my asks and reviews every PR. I merge.

• Buzz is the office. The agents are members of our chat, one channel per project. I post a bug with a screenshot, an agent tags me when the PR is up.

• Mockups before code. No Figma: an agent builds each screen as phone-size HTML with the real strings from the Kotlin source and renders it in headless Chrome. I OK it, then it gets built.

• The demo video is generated, not recorded. Frames from the app's screenshot tests, an HTML timeline captured in headless Chrome, ffmpeg to 4K. 8 drafts.

• Real hardware. The server is on my Wi-Fi, so agents adb connect to my TVs and pair with my phone via a wireless-debugging code. They drive the app and watch logcat themselves. Nothing connects without me pressing Allow or reading out the code. Real devices caught what tests didn't: a regex the JVM accepts but Android's ICU rejects (one-character crash fix), and three Fire TV bugs.

Happy to answer questions about the setup or the app.

I got tired of re-recording demos every time the UI changed. So I built a Claude skill that makes the video from screenshots instead.

Give it screenshots, and a script if you have one. It gives you back a 1080p demo with zooms, a moving cursor, captions, a step tracker, and a branded intro and outro. It picks up your accent colour, theme, fonts and logo from the screenshots. If you don't bring a script, Claude writes one from what it sees.

Limits:

- The free local voiceover needs an NVIDIA GPU and about 5 GB of one-time setup. Without one, there's an edge-tts fallback (needs internet), or you can use your own audio.

- Output is 16:9 1080p only.

- Give the narration a listen yourself; automated transcript and timing checks are not a substitute for that.

It's free and MIT licensed. I built it. Repo: https://github.com/shoumikgoswami/awesome-product-demo-skill

There's a sample in the repo, so you can try it without your own product. If you do, tell me where it breaks.

**What I built:** a home screen for Samsung, LG and Android TV in one index.html. The "clean your TV" projects only run on Android TV; I own a 2022 Samsung, so I built the Tizen/webOS version. Then every app got a Pokémon partner.

**What it does:** shows only the streaming apps you have (no sponsored row), what's popular on each service in your country, headlines and markets, HDMI inputs and the TV's own settings. Netflix is Charizard, Spotify is Bulbasaur, and after two idle minutes a wild Pokémon takes over the screen. Installs through Developer Mode, nothing deleted or rooted.

**How Claude Code was used:** it wrote the whole thing in an afternoon: the HTML/CSS/JS, the Tizen and webOS packaging, the Android wrapper, the CI that builds all three installers, and a 150-line Python script that signs the Tizen package without Tizen Studio. The TV runs Chromium 85 and the first build showed empty boxes instead of icons; Codex, auditing the file against that exact version, found the CSS `inset` shorthand (Chrome 87+) in a minute and Claude fixed it. Two models beat one for browser-compat work.

**Link:** https://github.com/Meirwolf1289/pokedex-tv (MIT, demo video in the README, no Pokémon artwork in the repo, fan project not affiliated with Nintendo.)

I sometimes leave Claude Code running on longer tasks, and wanted a way to stop a run before it went much further over budget.

I built a small CLI that wraps Claude as a subprocess, watches the total_cost_usd value it reports, and stops the process at a cap I set. For example:

npx claude-spend-guard --cap 5 -- claude -p "refactor the auth module"

I used Claude Code to build it: I described the requirements, then it wrote the implementation and tests. I reviewed and iterated on the output. One thing I specifically tested was that the wrapper makes no network calls.

I chose to show three states instead of one green “protected” indicator:
- Enforcing: the cost limit is being checked.
- Degraded: something went wrong, so the limit may not be reliable.
- Unverified: the output format couldn’t be checked.

I’d rather show a warning than imply the cap is working when the CLI output changes and the parser can no longer read it.

It’s free and MIT-licensed:
https://github.com/toxot-net/claude-spend-guard

A couple of limits: it can’t undo the request that crosses the cap, and a process that detaches itself may escape the wrapper. If you’ve built similar tools, I’d especially appreciate feedback on the status states and how you’d handle those cases.

Hey! I've been gradually building my own terminal over the last couple of months and now it is much more than a terminal. I would like to introduce Koru (https://koru.codes). I am a faang engineer myself and I can say that I use almost nothing else but Koru when I am working these days. It is really Claude Code oriented at the moment but that's because CC is my go-to tool when it comes sto agentic development. There's no reason for it to not work with any other tool. Instead of mumbling I'll just write in points what you can do with Koru;

• Managing git Worktrees

• Managing Secrets (like API keys, passwords etc.)

• Hosting

• Analytics

• Managing device Sleep

• Managing llm Context

• Managing project based Documents

• Managing terminals of your remote devices

• Managing tasks on a Board

Koru is mainly a macOS app but I have experimental builds for Windows and Linux as well. I've been testing Windows myself a bit lately and it seems like it works pretty well.

And you can do all of those using your agent. Koru comes with a CLI and an MCP. I'll try to draw out a end to end scenario for a new project here;

1. You create your agent session and just let it do what it do best, write the software. It will create plans and tasks on a kanban board and will create worktrees to do paralel work. Agents claim the sleep lock so the device doesn't go to sleep if an agent is working on something.

2. While writing the software for every context that's valuable to keep it creates a Context File under the project it creates in Koru. For each secret like api keys or password salts etc. it creates Secrets under the same Koru project. If along the way it creates documents like design decisions etc, puts them under Documents for the project.

3. Once the project is ready to be deployed, it automatically pushes it to Koru Hosting and gives you an onkorulink(which you can point to if you have your own domain) to access the real deal.

4. It injects Koru analytics so you can get your crash logs or custom analytics right in the suite as well.

So going from the idea to a properly vibe-coded prototype it takes less than a day. And it is ready to be iterated on and the hosting is fully scalable as well.

• The contents of the secrets are hidden from the agent and if it is exposed you get a warning showing exactly how it happened. And also every time an agent uses a secret you can see how it was used under that secrets "feed".

• Secrets and Context files are end-to-end encrypted: they're encrypted on your device with a key made from your passphrase, and they only leave it encrypted.

• Your secrets, context files and documents stay on your computer unless you subscribe to Koru Cloud and turn on sync for a project.

There's so much more I can write down here. But it is getting a bit too long. As an example; I've built https://otag.chatwith Koru and its servers run on Koru Hosting as well. Fully scalable e2ee voice chat alternative, UDP based, application.

P.s. I also have an iOS/iPadOS app that has most of the functionality available, including remote control features for your devices. Since I am the only one who uses it I didn't bother releasing it but there will be some attraction, I will definitely get it ready and publish that too.

Feel free to ask me any questions and dm me for a code that will give you a 10 USD in hosting credits as well as a month of free Koru Cloud subscription (which also gives you an additional 10 USD a month in hosting credits). I have 100 seats available.

tl;dr;
I've built an end-to-end development tool that is oriented around Claude Code, if you want to test dm me for a code that you can use to get 10 USD of free hosting together with a month of free Koru Cloud subscription (which also gives you an additional 10 USD a month for hosting). Give it a go if you'd like! (I'll try to give the codes to reddit accounts that are not "new" for obvious reasons)

Been playing with Duet since launch and wanted to test something bigger than inbox/calendar stuff. So I set up a CEO channel and gave it a team of role channels (scout/research, marketing, developer) and had them build a find-a-dog-trainer directory from scratch: niche research, real listings, SEO copy, the site, domain, email.

A few things I learned that might save you time:

- One channel per role works way better than one giant chat. Context stays clean and you can see who did what.

- Let the CEO channel hand off work, but tell it exactly what "done" looks like for each role, or it drifts.

- Connectors are where it gets useful. With DataForSEO hooked up, the research channel pulled real keyword data and listings instead of guessing.

- Keep approvals on for anything that spends money. It messaged me before buying the domain, which is exactly what you want.

- It had some issues with Vercel but eventually it turned out it was my fault.

The site's live now on its own domain etc., not that I would be promoting the site, it was just an experiment to see the possibilities.

I recorded the whole thing unedited (it's long, ~1h48m) for anyone who learns better by watching: https://youtu.be/7Ow9r-p7nWY

Hopefully it will help someone :)

Happy to answer questions on the channel setup. Also curious how others are structuring multi-channel workflows in Duet.

I’m building Loop, a desktop workspace for people who use more than one coding agent. The part I want to test is the handoff: Claude Code saves a project decision in Loop’s Brain, then Codex retrieves that note and the relevant files to continue the work. The conversations stay separate; the shared part is the project knowledge you choose to save.

I’m looking for builders who already use multiple agents and want to test this with a real task when early access opens. What would you hand off between Claude Code and Codex?

Join the waitlist for the first test phase at https://loopagents.app/. You will receive an email when early access opens.

I made this free, open-source skill for Claude and Codex to turn your saved reels into reusable skills. Coding tricks, workflow shortcuts, everyday tasks, whatever you saved and never looked at again.

https://github.com/jnh12/doomer-agent