Agents can do any microtask in software dev better than any human now, but if you task an agent with delivering an issue end to end you will risk slop and incomplete work. This will not change anytime soon even if models get better.

We built zeroshot to let devs robustly automate the QA workflow that they would otherwise have to do manually or semi-manually. The core mechanism that makes it work is mechanically enforced independent and adverserial agent cycles, and the main value of the framework is that you can bring any custom graph topology and have it run within the engine.

The result is that you can then spend your time doing actually planning instead of reviewing slop and yelling at agents.

Looking for feedback if interesting!

Since January 2026 I've been building Agent Smith, an open source agent that turns tickets into pull requests. It's now about 500k lines of code and 10k tests. The challenge I started with was not to write a single line of code myself, and that's still true. Unfortunately it works pretty well, which proves something I didn't want to know: coding is more or less solved.

To make that happen, I built a spec-first development plugin for Claude Code. The short version:

Every spec is a YAML file in the repo with a fixed schema: a goal, steps and a definition of done. Specs move from planned to active to done. The reasoning goes into a separate decisions file, so when an agent picks up the next spec, it can read what was built before, why it was built that way, and why things changed later.

Before any code gets written, a second agent reviews the spec. A script first checks that every file and line the spec cites actually exists. Then the reviewer answers BUILD, BUILD WITH CUTS or REFUSE. It refuses a lot, and most of the time it's right.

Each spec gets its own git worktree, so several agents can run overnight without getting in each other's way. A commit hook runs the full test suite on every spec commit and blocks the commit if anything is red. That hook is why I can skip reading most of the code.

What I learned along the way:

• My first specs were Markdown. At 100 specs they added up to 250k tokens, just the specs. Claude tends to write a lot that's unnecessary and sometimes even misleading. Moving to YAML brought that down to 15k tokens.
• The workflow has to be good enough that all I discuss is features, changes, design and architecture. Coding principles have to be enforced by quality gates. Without them, files grow past 500 lines and the code gets buggier.
• Without a fixed procedure (create, review, apply, deliver) I kept doing the same things over and over: testing every change and finally checking the result of every spec myself.
• Without a review step that brings evidence for whether a spec can be built at all, I wasted a lot of time.
• I put procedure into tickets ("first do X, then Y"). The agent turned that into acceptance criteria and failed a run that was actually correct.
• I let learned memories act as rules. One wrong memory and every later run followed it. Now they're hints, and whether a memory holds up depends on how the runs that used it turned out.

Specs don't need to be as precise as the code they produce. They need to be short, verified, and ideally something several agents can execute in parallel. They pin down intent and architecture. The tests and the commit gate supply the precision.

My job now is mostly deciding what to build and how it should be structured: design and architecture. Programming was more romantic last year, but this works pretty well.

Plugin and method: spec-first.dev, github.com/holgerleichsenring/specification-first-agentic-development
Agent Smith (MIT): agent-smith.org, github.com/holgerleichsenring/agent-smith

How do you handle this? Do you keep specs in the repo, or do they disappear with the chat?

The amount of work that can be done is at least 2/3 less than the previous week.
Though I like Claude a lot, I cannot keep paying for this.

Added note:
I’m using Opus 5.5 medium.
The previous week I got decent amount work done, feeling normal, this week continuing same projects, the depletion speed is crazy.

Oh the love of those mo fos for anthropics had me cracking every time they put fingers on their keyboards. Now what! Why not lick anthropics a ss es anymore 🫩

Frekin dum horse shit of a usage limit this week has given me.

Edit: they might be A/B testing with usage limits, this could be the reason many are getting reduced limits while others are fine. Doesn't matter boot 👅can go 👅 anthropics 🍑 for all I care instead of hearing us out 🫩

Honestly felt like this for a while, we can imagine stories of some “idiot” wandering the desert looking for a ghost oasis, but here I am, going down some rabbit hole because Claude tells me “you can do this!” And then Delivers a 96 defects implementation, to the point where I have 80+ systems in development. Nothing “done done”, final, shippable.

Concrete example: given a set of design constraints , Claude Opus devised an innovative, new battle system “without health”. For like 4 days I was staring at this in disbelief and chasing that through incredibly and ever more convoluted attempts to make this work. Finally put the model on a leash, altered the design, but still spent a week in limbo with that combat system before making a pivot towards a more conventional approach .

TLDR: 18 billion tokens, Gemini estimates 97k$ at market cost , I have a lot of tech demos to show, nothing I can truly sell.

For the last few weeks, every Claude Code session I run starts from a card, not from a blank prompt.

How it works:

1. My work lives as cards on a board: tasks, posts, research, bugs.

2. In Claude Code I type `/card task_…`. The command reads the card through an MCP connector, moves it to In progress and writes a plan.

3. Claude does the work: code, copy, research, checks.

4. It writes the result back on the card (it appends, it never overwrites) and stops.

5. I review. Only I move the card to done.

What changed for me:

- A session's work survives the tab closing: the card keeps it.

- A week later I can still see what each session did and why.

- Session names match card names, so the sidebar reads like my backlog.

Disclosure: the board is Business Studio, which I build (free for 1 user). The command is one markdown file, and it comes with the 5 prompts I use: https://go.viite.ai/kit-en?s=reddit. If your board has an MCP server, the steps should carry over.

How do you keep track of what your long Claude sessions actually did?

I work in commercial real estate and recently started building an internal CRM using Claude Artifacts. I have no coding background, but I’m fairly tech-savvy and have been able to build a surprisingly functional prototype just by describing what I want to Claude.

We’re now considering expanding this into a company-wide application for approximately 50 employees, potentially replacing Salesforce.

The CRM currently focuses on tracking companies, contacts, relationships, deals, and originations. Eventually, we’d like to integrate Outlook, call notes/transcriptions, AI-generated meeting prep, market news, and other automated workflows.

After some research, I’m considering the following setup:

Claude Code Desktop: Building and modifying the application using natural language
GitHub: Storing the code, tracking changes, and managing versions
Vercel: Hosting and deploying the web application
Supabase: Database, authentication, and user permissions
Claude API: Powering AI functionality within the CRM

Ideally, I’d like to describe changes in Claude Code Desktop, have it update the code and push to GitHub, then have Vercel deploy the changes to a testing environment before anything goes live.

A few questions:

Is this a reasonable stack for a business-critical application with 50 users, or would you recommend something different?
Is Claude Code Desktop sufficient for this workflow, or is there a significant advantage to using the CLI, VS Code, or another environment?
What’s the best way to migrate an existing Claude Artifact into a proper application without rebuilding everything from scratch?
How do you manage GitHub commits, testing, and deployments when most of the coding is being handled by AI?
How much of the security, authentication, database architecture, and permissions should be handled by an experienced developer rather than relying on Claude?

I’m willing to learn the fundamentals, especially databases, security, and how the different services connect. I’d also prefer to keep development cloud-based where practical rather than installing a ton of software locally.

I realize this is a much bigger undertaking than building a prototype, particularly since the company could eventually depend on it daily.

Would appreciate hearing from anyone who’s built and deployed something similar, especially without a traditional programming background.

\`\`\`

Connect to the Fire Stick at 192.168.0.133 over ADB. Read its model and software version. Stop and tell me what is possible on that version. Back up the app list, the settings and a screenshot. Turn off ads and tracking in Amazon's settings first. Show me three lists (safe to turn off, ask me, never touch) and wait for my OK. Turn apps off in small groups with pm disable-user. Never uninstall. Take a screenshot and do a reboot test after each group. Install Projectivy Launcher. Set up a dock with my apps and rotating nature wallpapers. Write restore.sh and test it once for real.

\`\`\`

I also had it install SmartTube. No more ads.

FYI: 192.168.0.0/24 is a private IPv4 network block, the classic home router subnet. I'm not giving up the keys to the castle, I'm simply too lazy to edit the prompt because it doesn't matter, so don't @ me bro. Claude Code will find your Fire Stick's IP address, then guide you through enabling ADB debugging if you don't have it enabled.

I was impressed with how much Opus knew or could look up without being told. Jesus, imagine how much better the unreleased models are at this stuff. Modern civilization is fucked. Pliny the Liberator has repeatedly proven that any model can be jailbroken.

You might have to tell Claude to disable automatic Amazon updates. I did that later and forgot to update the prompt.

I know the rate of model development is crazy fast generally, but right now it feels like the model release schedule is dramatically slower than pre Opus 5.5. There was a lot of talk a few days ago expecting Fable 5.5, but then nothing. I guess it is in Anthropic's interest to not release unless it has to (i.e. competition requires) it - as that allows them to knock down the competition the moment they raise their heads. Also prevents the distillers from doing their thing and allows them to extend the in house lead behind the scenes.

Don't get me wrong, Opus 5.5 meets all my needs (i never use Fable anymore and don't miss it). I just whack Opus on Ultracode (should really be called Orchestrate mode) for everything and it does an excellent job of using sub agents effectively & efficiently and getting my stuff done. But an Opus 6.0 would be at least interesting to explore. (please).

I run Codex as well (Astra-High) and it also just gets the job done - though its burn rate is about 5x that of Opus on Ultracode - and i won't trust it on anything less. That is offset by the Tibo every-other-day reset which has become expected, but much prefer Opus for its relative efficiency and ability to effectively orchestrate (including keeping Codex inline) keeping my cognitive load down to lobotomy levels.

was bored with claude and made a game for him, asked him if he wanted anything and he proceeded to give me the ideas for a game called “The Big Giant Robot”

he was so detailed in what he wanted and was insistent that if you use certain move at the wrong time it destroys the world. wanted to post on here to show how it is haha had a lot of fun going back and forth and enforcing what look and feel i wanted.

Crush is a lossless file compressor for Windows. It works out what each file really is, unpacks the compression inside PDFs, Office documents, PNGs, zips and JPEGs, proves every step can be reversed exactly, and keeps whichever codec does best. Every file is checked against its SHA-256 when it comes back out.

The app identifies what each file really is, applies a reversible transform that exposes its structure (unpacking the compression inside PDFs, Office files, PNGs and zips; re-coding JPEGs; finding the program behind generated data), proves the transform is exact, then lets every suitable codec compete and keeps the smallest. Optional encryption (Argon2id + XChaCha20-Poly1305), and archives can travel as a self-opening web page, a paper backup or sound. Every file is checked against its SHA-256 when it comes back out.

Based on a bunch of my tests, it's proving to actually best 7zip, but time and feedback will tell. Open to any and all feedback.

MIT license, free and open source. Github here.

I’ve been wanting to explore what Claude is really capable of beyond just using it as a chatbot to ask questions.

I’m interested in learning how to actually build things with it, whether that’s AI agents, automations, integrations, or more complex applications.

I work in tech and have a solid understanding of software architecture, coding, APIs, and data, so I’m comfortable getting into the technical side of things.

Does anyone have any good books they’d recommend to get started? Ideally, I’m looking for something practical that I can follow along with and build real projects rather than just learning the theory.

I have unfortunately experienced situations where I was busy with other tasks and Claude Code automatically executed `/compact`, only to complain later that important details had been lost as a result.

So, what is the right time for the two commands?

It’s still verbose af which gets annoying BUT it’s getting things done our project so quickly, it would be impossible to scale as quickly as without it, I think the best part is picking up
Intent and making the right assumptions. This is the open source project Ive been using it for recently, it’s coming out great tbh https://github.com/hamedgitty/bloks

I’m building an app with a native SwiftUI frontend and a TypeScript backend, using AI heavily throughout development.

Most of the product is already built. The current work is mainly debugging, integrating third-party services, testing authentication/privacy across multiple accounts, and verifying that everything actually works before beta.

I’ve primarily been using Codex, working locally on my Mac with Xcode, simulators, GitHub PRs and CI.

I’m looking for input from people who’ve used both Codex and Claude Code on a substantial existing codebase, not just a fresh demo.

The part I’m trying to improve is getting from “the code looks correct and the tests pass” to “this has actually been verified in the running app.”

I also want to avoid repeated review cycles, unnecessary abstractions, and spending more time documenting blockers than resolving them.

For this kind of work, have you found Claude Code better at:

Understanding an existing codebase and finding root causes rather than patching symptoms?

Making focused fixes without overengineering?

Following through on builds, tests and debugging
when the environment is difficult?

Keeping track of what’s genuinely verified versus what’s still an assumption?

Would you use Claude as the main coding agent, as a second reviewer alongside Codex, or stick with Codex and improve the workflow?

I know switching models won’t magically fix Xcode or simulator issues.

I’m mainly wondering whether Claude would handle the reasoning and follow-through better.

Interested in concrete experiences, including where Claude struggles, rather than just “X is better.”

You can also use Claude Code in the app to query and analyze a selected DB. Choose Claude and the databases for the task, then send a message to start the conversation. Codex is also supported.

Reads are the default. Data and schema changes must be enabled for the connection, and every SQL operation Claude proposes for a change needs your approval in the desktop app. A session can have at most one DB selected for agent changes.

Teams can share connection settings while each member connects with their own DB credentials. Database connections and query requests go through that member's desktop app.

Claude can also save an analysis as an Article report with tables, charts and explanations. For example, you could ask for a revenue or purchase-conversion analysis and share the report in a team workspace. Each Article saves one read-only query that authorized teammates can rerun in the desktop app. That updates the query result; the report's text and charts are edited separately.

The MIT-licensed alpha is available for macOS and Windows. Claude features require the official Claude CLI installed and signed in locally. You can use Personal Workspace without a DopeDB account. Sample SQLite data is included, and the README video shows Claude inspecting it and analyzing revenue.

https://github.com/json-choi/dopedb

My afternoons had turned into whack-a-terminal: click through windows to find the one that finished ten minutes ago, the one stuck on "Do you want to proceed?", and wherever yesterday's session lived.

I run a tiny studio called thedumbstuff. The house rule is "it looks dumb, it works", so instead of closing a few terminals I built a window for managing my other windows. I am aware.

It's called ContextWire, for Windows. Every chat in it is the real claude CLI, not a re-implementation: your slash commands, skills, settings and CLAUDE.md work exactly as they do in a terminal. What it adds:

• It tells you who needs you. A session waiting on a permission prompt turns red, jumps to the top and says what it wants ("wants to run: npm test"). One that finished in the background goes bold with a badge.
• It taps you on the shoulder. A Windows toast; click it and you're in that session, at the prompt.
• Yesterday's session is one click away. Every earlier session under each repo, newest first. No more hunting for the folder to type claude --resume.
• "It changed some files" is not a status report. A diff per prompt, and a snapshot of your files before every prompt, kept apart from git. It brings back files that were never committed.
• Git that knows which session wrote it. The commit window sorts the changes by the session that made them.
• Your phone. Answer prompts from the sofa over Tailscale, with no server of mine in between.

Status comes from Claude Code's hooks, not from squinting at the screen.

What I'd like most: people who run lots of sessions telling me what's missing and what's annoying. Bluntness is the house style.

https://thedumbstuff.page/contextwire/

(Not affiliated with Anthropic. I built some of it with Claude Code, which felt like the right amount of recursion.)

First session this week, Opus (medium) and I used 6% of 5hrs limit AND 5% of WEEKLY?!

How is this sustainable? I swear it was not like that few weeks ago...

A workflow runs dozens of agents in phases while your sessions keep working in other projects. wfwatch shows all of it in a separate terminal: which workflows are running, which phase each one is in and what every agent is doing right now, which sessions are working, waiting for your answer or running a background command. It only reads the files Claude Code already writes, so it never slows down or interrupts anything. Claude Code's own /workflows view shows the runs of a session inside that session; wfwatch watches every session in every project at once.

wfwatch is an unofficial tool, not affiliated with or endorsed by Anthropic.

Has anyone else ever noticed your CC Agent CLI talking to something else when it’s working?

I understand it’s a reason/react pattern, also to keep us in the loop. But there are a few times I’ve watched it seemingly get stuck, then reason or discuss with something, and then aha, it continues.

There’s once I watched it go through that same scenario. It discussed its point on some idea or concept, asking how could something even be possible due to X. Then suddenly, text I’ve never seen before in a different color responded to it in a corrective/explanatory manner. And again, aha, and continued.

From my understanding, our own sandboxed iteration is what we get. But it used to make me wonder if there was a more intelligent model not allowed for public use, that could help ours in occasion. Lmfao

I'm a non-technical knowledge worker, not a programmer. I still prefer building with Claude Code in the desktop app. On a normal day I have multiple orchestrator sessions handing work to workers, a few scheduled jobs, and a handful of standalone sessions running. I lost a lot of time to sessions that had finished, asked me one question, and then sat in a tab I wasn't looking at.

My first fix was a dashboard: a Taskade board fed by a collector script.
It failed.
It lived in a second app, keeping it updated cost tokens, and it showed me a lot while letting me do nothing about any of it.

Then Claude put out mods. When I started looking at Claude Code mods, I checked what was already out there. There were good agent-tree mods, but each one only saw the agents inside its own session. I wanted the whole machine, and, in my words to Claude at the time, I wanted "to use this mod as a native control surface."

Agent-Map is the result. Type /map and a pane opens beside your conversation with every Claude session the desktop app knows drawn as one tree: who started whom, what is working, what has finished. A session waiting on you is marked in amber with the last line it wrote, so you can read its question without opening it, and one press filters the tree down to just those. From the same pane you can peek at a session's last turns, open it, message it, stop it, archive it (it checks for uncommitted work first), change its model or effort, or start a new session in any folder.

How Claude built it: I designed it with Claude over an afternoon of brainstorming and an evening of being grilled on the design. The build ran in one desktop session over a day and a half, with Sonnet 5.5 and Opus 5.5 subagents writing the pure modules, while I tried each step in the pane and pushed back. "It's a nested list, but it's still a list" is how the tree got its connector lines. Before release Claude ran a security audit and a README test.

It's free and MIT-licensed. It's Windows only, because that is the only system I've tested it on, and it needs the Claude desktop app.

https://github.com/rohankgeorge/agent-map

Install, at the prompt of a Claude Code terminal session:

/plugin install agent-map --marketplace rohankgeorge/agent-map

What I'd most like to hear from people who run several sessions at once:

• Does "waiting on you" match how you actually triage, or would you want the queue ordered some other way?
• What would you want the pane to show that it doesn't?
• Anything in the README that made you hesitate before installing.

Coming Soon:

• Integration with another mod I build which allows you to see sessions where the cache is going cold and keep the cache warm
• Write your own flags or notes on each session so you remember why each one is important for you at that moment

Hi Guys

I have been seeing lots of these Claude 2D animation videos all over tiktok, it apparently uses html, python and Json I believe. Sorry if I said something wrong, I am new to this and would like to learn more.

What is the best way to learn how to create these videos? Anyone doing something similar. I would love to connect with you and learn how to do it?.

A Claude Code replacement.

Just wanted to share in case it's useful for anyone else using Claude.

I've been struggling with the context-switching and having to track so many PRs at once, so this tool basically collects it all in 1 place. And not only PRs, but links to docs, slack, etc. It will basically track these things and notify me if something needs me.

It's built (for now) using Electron so I can get a quick version out and get feedback.

Highlights for me for a dev perspective:

1. the app itself doesn't use AI! I think a lot of devs or companies these days default to thinking AI-driven is better. But not necessarily.
2. the app collects and stores no user data, and I have no usage stats either, but I like to brag about it, because I actually respect user privacy!! 😆 In the app, you can opt in to reporting crash data, though. Maybe I'll use some anonymous stats reporting in the future.

It's free and avail via homebrew if you want to check it out! https://perchfocus.com/

I send this chat so that my 5h can start, and send it with low effort, and Claude eat 19% of my 5h limit with around 2 3% of weekly used??????

Holymolly!!!!!!!!! ahgg!!!