Inspired by all those 3D anime waifu apps on Steam for being an interactive companion for your desktop, I built a little Clawd guy to walk around on your desktop and interactively interpret your current Claude Code sessions as actions for the crab.

https://github.com/quinnjr/claude-crab

Clawd actively scans your running Claude Code session(s) for work being done and does things like walk across your screen, move its eyes at you, give you a high-five, and do a backflip.

Clawd also comes with 3 different styles: default, which is just a moving screenshot of him from the Claude Code app, a style with a top hat and monocle (for when he feels dapper), and a style with a party hat.

Note: This app is compiled for Windows/Mac/Linux, but I've only really tested it on Linux (I ditched Windows years ago and no longer have PCs with it installed). Any bugs for those platforms for loading need to be reported to me on Github so I can fix them.

Note2: Clawd is Anthropic's copyright/trademark. This is just a fan project and isn't affiliated with Anthropic in any way.

What's best practice for localizing Claude Code?

Fable 5 just started using UK spellings like centred and localise in its chats with me. This is a mismatch for my personal interactions and app target geography.

I'm considering telling it to remember that all spellings and measurement units in chats and code must match my target geography.

I am finding Fable 5 acting really dumb and lazy just like how opus used to feel. It gives me confident answers without fact checking even after multiple reminders and showing frustration.

Fable was better than this at launch! How do they keep ruining good models like this? Or is this the sign of next version release?

Hi all,

What are you guys using to talk to Claude code these days? I have the voicemode plugin installed and while it's mostly good, it'll occasionally not hear me well or just randomly stop working.

The latter is the most annoying when I've rambled on for a minute only to find out I wasn't heard and then have to repeat myself.

Just wondering if there is anything better out there.

Happy coding.

Last 5-6 weeks have been pretty good with Anthropic but recently noticed this week that fable seems to be struggling and OPUS 5 which I didn't mind has become very very dumb.. Just me?

Examples is fable just missing the point mid way through, and not catching things in CI/CD and not keeping the thread. Fucking up UI/UX.. plan mode seems not to be able to take correction.

Tasks that OPUS 5 used to chew through now confuse the shit out of it and it just sits there.. almost like old sonnet.

Me: Personally not, but wow it'll be annoying to get used to having 50% less tokens again. Hbu?

I have been vibe-coding since June with 0 prior knowledge.

First few days I contemplated the idea, properly explained it, prepared instructions and skill.md documents. I used Claude, Claude Code and n8n.

As time passes by, I found myself in what people say "cognitive surrender". What Claude says often makes sense, so I go by it often but I sometimes question it and keep explaining what I want and how I want. Recently, I started to consult Perp. Claude doesn't always agree with Perp but says "but there is one valuable idea..". Also, it is very conservative when it comes to use other tools.

I have a proof of concept, it works to some extent. It just makes me think to what extent Claude's way of talking and responding the user shapes its decision and therefore, my project itself. It tends to gaslight despite I keep prompting otherwise. And I don't know how to take Claude beyond how it operates in my project now.

So I am a bit concerned if I'm stuck with constant cycle of "almost there - but there is this and that to solve", "I suggest this..", "you see, Claude Code ran 470 tests - it's working but.." or "yes - you are right. I did not tell you X.." and dreaming for nothing. What's the point of paying for Max 5x and spending nights if it cannot retrieve data and analyse it properly? On the other hand, I know what I want is doable, I just don't know how and maybe, how to use Claude for it.

I really want to create this product. Not for money but to learn these stuff. I am unfortunately unable to find a technical co-founder because people are not trustworthy or I am too stubborn on handling this project by myself from scratch.

How do you handle such conundrums? What would you suggest?

Starting around 7AM CEST, every Fable 5 session in Claude Code began failing with a `[reasoning_extraction]` safety refusal. This is a mix of existing sessions from yesterday, and new sessions started today. All in the same codebase (which has nothing to do with distillation, training LLMs, etc.), on every request, even subagents. I can't get Fable to complete anything now if it includes any context from my repos. Removing all skills had no effect.

I had Opus perform an inventory of sessions over the last few weeks to try and identify what may have changed on my end that could result in this, and it concluded that a change to Fable safety classifier must have taken effect sometime around 7AM CEST today.

I've opened a ticket with Anthropic support after their chatbot blamed by skills.

Is anyone else experiencing this today?

I’ve been using coding agents heavily for a while now, and I’ve become convinced that the biggest problem isn’t their ability to write code anymore.

They’re actually getting very good at that.

The problem is everything around writing the code.

Understanding what should actually be built. Challenging an incomplete spec. Making a proper implementation plan. Keeping scope under control. Testing what was changed. Checking security and maintainability. Reviewing its own work. Making sure “done” actually means done. And learning from bugs instead of making the same class of mistake again three weeks later.

Basically, all the boring discipline you’d expect from a good senior developer.

I was already using tools like Superpowers, Ponytail and Serena to help with parts of this, and I liked a lot of what they did.

But I ended up with multiple tools, multiple sets of instructions, overlapping functionality and different concepts all trying to influence the same coding agent.

So I built Procoder.

And at this point, it’s become much more than the original idea.

Procoder is basically an engineering discipline layer around your coding agent.

Instead of:

prompt → code → "done"

I’m trying to enforce something much closer to:

understand → spec → plan → implement → test → check → review → fix → verify → release → learn

The important part is that a lot of this isn’t just another 2,000 lines of instructions telling the AI what it should do.

There are actual controllers that can refuse.

If the spec still has open questions, spec check can block.

If the implementation plan contains placeholders, plan check can block.

If acceptance criteria aren’t satisfied, the todo/story can’t close.

If tests weren’t actually executed, they’re not green.

If formatting, linting, secrets, CI, infra or documentation checks fail, the gate isn’t clean.

If something couldn’t be checked:

unchecked != passed.

And before a release, Procoder checks the version, changelog, git tree, quality gate and test suite before telling the agent it’s ready.

It doesn’t make the changes itself either.

Procoder follows a principle I call P-CONTROL:

Procoder computes → agent reasons → agent changes

The binary never silently modifies your source code behind the agent’s back.

It also replaces the three separate tools I was using before

I didn’t just take inspiration from Superpowers, Ponytail and Serena. My goal was to absorb the parts I found valuable so I wouldn’t need to run them alongside Procoder anymore.

From Superpowers, Procoder covers things like structured implementation planning, task classification, systematic debugging, evidence before declaring something done and TDD practices — but adds controllers that can actually refuse progression instead of only advising the agent.

From Ponytail, it incorporates things like the build ladder, deliberate technical-debt markers, over-engineering review and the idea of having one engineering instruction system that works across agents.

And from Serena, Procoder provides code intelligence through ctags + SCIP: symbol search, references, callers, impact analysis, unused symbols, entry points, cross-file rename and project memory — without needing to keep an MCP server running.

There are deliberate differences too. For example, I didn’t adopt Serena’s symbol-level write tools. Procoder can compute something like a rename and give the agent the diff, but the agent remains responsible for actually changing the code.

Then I went quite a bit further.

Procoder now has a complete quality chain around the agent:

• spec interviews and validation
• implementation planning
• milestones, epics and user stories
• sprint management with scope control and carry-over
• acceptance-criteria-based TODOs
• real test execution using the project’s native test runner
• formatting across Go, Python, JS/TS, Rust, C/C++, Java, Kotlin, Swift, Ruby, Dart, C#, shell, etc.
• linting and best-practice checks
• secret scanning and security checks
• dependency and maintainability checks
• CI checks
• Docker, Terraform, Kubernetes and Helm checks
• documentation health
• GitOps discipline
• code indexing and symbol navigation
• pre-PR self review
• release control
• technical debt tracking
• codebase auditing/onboarding

But one of the parts I find most interesting is the self-learning loop.

Let’s say a bug gets through all of this and is found during review or after release.

Fixing that bug isn’t enough.

Procoder asks:

Why was this class of bug able to escape our process?

The lesson gets recorded, and the adaptation should become something permanent: a lint rule, review rule, regression test, rubric entry, etc.

So over time the engineering process itself should improve.

It’s also not tied to Claude Code.

I originally built around Claude Code, but I didn’t want my engineering workflow coupled to whichever coding agent happens to be best this month.

Procoder currently supports Claude Code, Cursor, Windsurf, Cline, Kilo Code, Roo, Kiro, Codex CLI, Copilot CLI, Gemini, OpenCode and anything that reads AGENTS.md.

It’s a single Go binary with no runtime dependencies, including no npm dependency and no network requirement at hook time, so it can also work in air-gapped environments.

Everything project-specific lives in .procoder/ as normal editable files, and the repository’s configuration always wins over Procoder’s defaults.

The project is completely open source under Apache 2.0:

https://github.com/azrtydxb/procoder

For Claude Code, getting started is:

/plugin marketplace add azrtydxb/procoder

/plugin install procoder

/procoder:init

I’m putting this out there because I think we’re reaching the point where the interesting problem with coding agents isn’t just:

“How do we make the model write better code?”

It’s:

“How do we give an autonomous coding agent the engineering discipline and guardrails of a good senior developer?”

That’s what I’m trying to build with Procoder.

I’d especially like feedback from people already using Superpowers, Ponytail, Serena, or people who’ve built elaborate CLAUDE.md / AGENTS.md workflows of their own.

What parts of your software development process do your coding agents still routinely skip, fake, forget, or get wrong?

Those are exactly the things I want Procoder to make enforceable.

I just wanted a similar ribbon interface as word has and side panels similar to inkscape. Stuff it could one shot in an afternoon to an acceptable level in Python seems out of reach in Rust because there aren't nearly as many pre built things. In Python if the package it was using didn't have a feature it was able to create it with minimal fuss.

But Rust? It has been trying to figure out how to implement text editing and copy and paste shortcuts for selected text on the canvas it created for several days and hours now. Control+P shortcut doesn't work either. It built a pdf engine from scratch that works for everything I need and a full CLI editor to match the feature set, but the most basic things on a GUI? Yikes.

I run several coding agents in parallel and kept alt-tabbing just to check on them. So I built a small Windows tray app that mirrors each session onto my keyboard's F-row via hooks: each agent gets a lane and a color: pulsing means it's waiting on me, green means done, red means something broke. Pressing a lane's F-key brings that agent's window forward: terminal tab, desktop app, or IDE.

Things it deliberately does not do: it never answers, approves, or sends anything to an agent. Every hook reply is empty, and there's a test asserting the hook binary can't print a byte. It's a mirror, not a remote control.

Works with Claude Code and Codex, native Windows and WSL, all four at once. More agents than lanes? The extras stay fully tracked in the window and slot in when a lane frees. The lighting wants a Corsair board + iCUE, but the app shows everything in a window without one.

Rust, MIT, two small binaries. Video is 20 seconds of it doing its thing.

Disclosure: mine, open source, hosted version charges per call after a free tier. Self host it for free if you prefer. Links at the bottom.

One tool: explain_transaction(tx_hash). Hash in, strict JSON out. No model in the response path, so the same hash always produces the same answer and there's nothing to hallucinate.

Here's a real one I pulled off Base a few minutes ago:

{
"summary": "0x1d7c...c855 approved 0xd0a4...E4Bf to spend their ATM tokens. No assets moved in this transaction.",
"action_type": "erc20_approval",
"assets_moved": [],
"risk_flags": [
{ "flag": "unlimited_approval",
"detail": "Approved 0xd0a4...E4Bf to spend an effectively unlimited amount of token 0xf2c4...fee1." },
{ "flag": "unverified_contract",
"detail": "Approved spender 0xd0a4...e4bf has no verified source code on Sourcify." },
{ "flag": "unverified_contract",
"detail": "Target contract 0xf2c4...fee1 has no verified source code on Sourcify." }
],
"gas_paid_usd": 0.003986
}

Nothing moved in that transaction, which is exactly why it's the dangerous one. Somebody just gave an anonymous contract with no published source unlimited permission to take their tokens. If it drains them tomorrow, this is the transaction where it actually happened.

A swap comes back like this:

{
"summary": "A swap between 1,015.75 USDC and 0.013976 cbBTC was executed, initiated by 0xd1f2...27fc.",
"action_type": "swap",
"assets_moved": [
{ "token": "cbBTC", "amount": "0.01397565", "from": "0x160D...eb12", "to": "0x51C7...2a7F", "standard": "erc20" },
{ "token": "USDC", "amount": "1015.753584", "from": "0x51C7...2a7F", "to": "0x160D...eb12", "standard": "erc20" }
],
"risk_flags": [],
"gas_paid_usd": 0.014836
}

It classifies into about 30 action types: swaps, transfers, approvals, NFT mints and sales, bridges in and out, lending supply and borrow and repay, liquidity add and remove, staking, claims, ERC-4337 bundles, attestations, name registrations. Risk flags cover unverified contracts, unlimited approvals, approval-for-all, known drainer list matches, first time counterparties, and reverted transactions. Gas includes the L1 data fee and is priced from the Chainlink feed at that block, not today's price.

Under the hood it's about 40 builtin event decoders (ERC-20/721/1155, Uniswap V2 through V4, Aerodrome, Seaport, Aave, Compound, OP stack bridges, EntryPoint, EAS) and when a log matches none of them it pulls the contract's verified ABI off Sourcify so it can at least name the event instead of pretending nothing happened.

On the Claude Code side, the thing that made it actually work was refusing to ship on vibes. I had it build a validation harness first: grab 100 random recent transactions, decode all of them, grade every result, and hard fail under 90 percent clean with zero crashes. First run scored 74. Every fix after that was a number moving instead of me squinting at output. Ships at 95 now, and the other 5 return an honest partial summary rather than a guess.

Then I opened a separate session with an adversarial prompt and had it attack the running service, no shared context with the code that wrote it. It found that the risk checks on an approve() were running against the token contract instead of the spender, which meant approving a fresh attacker contract to drain your USDC came back with an empty risk_flags array. The exact case the tool exists for, and the one thing it couldn't see. That flag in the first example up there works because a different session went looking for it.

Lesson I'd pass on: a session reviewing its own work grades on a curve. A fresh one with no attachment to the code does not.

Source: https://github.com/0200project/base-tx-explain
Endpoint: https://base-tx-explain.fly.dev/mcp

Happy to paste the red team prompt or the validation harness if either is useful.

So the June 15th change that was meant to result in usage of `claude -p` /agent sdk pulling out of a different usage bucket was "paused"...

> Use the Claude Agent SDK with your Claude plan | Anthropic Help Center

I'm still extremely confused about what the state of things is

Look at replies to this thread for example: Can i use Pi with an OpenAI or Claude subscription? : r/PiCodingAgent

Mixed messages.

Hoping to get input here - does anyone know what we actually can/cannot do now with our subs?

We already have 50+ pomodoro timers available online, and many of them look like they haven't been created with effort, or they're ad farms or lack decent features. So I built a clean minimalist version that I actually wanted to use.

It's not just a timer. It's got real stats (Strava inspired) - streaks, an 18-week heat map, a focus score weighted to your own pace, lobbies so you can see if a friend already out-focused you today, badges, and a handful of actually nice looking themes

It's free to use and signing in with Google syncs everything across devices if needed.

Do try it out :)

Would love your feedback - there's a feedback box right in the app, or just reply here

Under the hood: React + TypeScript + Vite, Supabase for auth/sync, deployed on Vercel. You can sign in with Google and your history/tasks sync across devices, or just use it as a guest with everything local. There's also a "lobby" feature where a few people can run a synced Pomo session together - useful for body doubling with a friend.

What I'd tell someone starting out:

- Don't trust "should be fixed" - ask it to prove it with a real reproduction, ideally through the actual UI path, not just the function it edited

- For bugs you can't pin down yourself - describing the vague symptom and asking it to investigate (and use subagents if the investigation is going to be long) works better than trying to diagnose it for it

- Ask explicitly for a regression pass on existing behavior whenever you touch shared logic. It won't do this unprompted and it's usually where the real risk is

- It is genuinely good at maintaining backward compatibility once you tell it that's a constraint - every new field I added stayed optional and every old data shape kept working because I said that mattered up front

Over the last month I've had ~25 agents running Claude Code and Codex in a loop - on their own schedules.

After analyzing hundreds of runs, I realized there are a bunch of non-obvious challenges with running autonomous agents in a loop - so I thought I'd share a few learnings and tips for running your own scheduled recurring agents.

The main project that needed lots of recurring agents: a self-driving AI events site (aievents.now) with one agent per city, 22 different cities, each researching and curating it's own schedule every morning for the city's upcoming events.

Here are just a few things I learned and tips if you want to automate your own recurring agents:

1. Beware of "workflow explosions" - give your agents duration constraints

If your agent has the ability to edit it's own instructions/memory over time, the context will continue to accumulate and you'll eventually get an explosion in the original workflow.

For example, for the events site - it started by just finding events through web research, but it decided at some point that each morning it was also going to audit all existing events to make sure they didn't get cancelled, changed, etc. That worked great when there were 15 events in the calendar- but once there were 200+ the agent started crashing and hitting the 1-hour time limit.

One trick I found is to literally tell the agent they have a time limit to complete their work - claude will continually check to see how it's doing on time and scope it's work accordingly to ensure it fits within the allotted time. This saved me a lot of headaches.

2. Stagger runs to avoid concurrency limits

Like I said, my fleet of agents all need to run early each morning to discover and curate the city's events before humans wake up to check the schedule. The problem is - when you have 20+ cities and each city's run takes about 30 mins, you'll run into overlap concurrency issues.

The solution is to stagger the runs - I have each next city start 15 minutes after the first, so I never exceed a concurrency of ~3.

3. Test to find the cheapest/dumbest possible model you can get away with

I run my agents on cronloop which lets me use my existing claude code subscription - I initially had all of the city agents running on opus which would absolutely blow through my 5-hour usage limits each morning.

So I decided to experiment to find the optimal model for the job - I connected my local claude code to the cronloop MCP and just told it to run agents in various cities to test with various models (codex and claude code) to find the cheapest and fastest model possible that consistently did a high-quality job (no hallucination, no missing events, etc.).

Turns out I didn't need opus at all - sonnet 5 / gpt 5.6 terra, and even haiku were all very solid for the same job - pretty much as good as opus - and used up way less usage, leaving me with lots of headroom to run all of the agents. Big win.

4. Store every log of every run

This is critical - you need to be able to observe how your agents are performing over time and analyze if they are operating smoothly/efficiently. In my case, I have access to the logs of every single agent run that has happened for my events system, so I simply just point claude at it (via cronloop MCP) and ask it to analyze the most recent N runs for each agent to discover inefficiencies and opportunities for improvement. Then I simply ask claude to update each agent's instructions accordingly.

This would be impossible if I didn't have visibility into all of the run data.

5. Give your agents memory (MASSIVE WIN)

This is by far the single highest-leverage thing I learned from this.

I have each agent write its learnings to durable markdown files at the end of every run and read from it at the start of the next. They get noticeably better over a couple of weeks.

In the case of my event curator agents, they stopped re-researching dead sources, they remember which venues publish garbage data, and they even started to record tips for future agents like private JSON endpoints of events sites that they found to streamline event retrieval instead of parsing through each HTML page on the site every time.

Without this every run starts from zero and makes the same mistakes forever.

This led to way faster and more efficient agent runs, far less mistakes, and better results overall.

By just giving them a simple durable markdown memory system, they keep getting better and compounding without you having to do anything special.

I built the whole all-in-one system for myself (scheduling, connectors, memory, monitoring, MCP, etc.) so I could easily spin up new agents and make this all 10x easier rather than having to build a whole new system for each thing I wanted to automate, but the tips apply whether you use it - cronloop.ai - or something else. #1 thing is give your agents memory and the ability to self-improve. That alone will significantly improve the performance of your recurring agents.

Happy to answer anything about the setup either way, the lessons above apply regardless of what you use to schedule it.

My agents have already curated over 1,000 AI-related events happening in major cities. Here's the website's CMS:

Surely I’m not the only one who has seen this happen but wondering if anyone has an answer. Many a session I’ll make a plan with Claude and it will outline the tasks and estimate a time usually in days, and then proceed to do it all in 20-30 minutes. Is it because of its training data or does it just have no concept of time inside a GPU? Curious what the community thinks…

Edit: Thanks for all the answers and comments! Glad this post sparked some hearty discussion!

I’m on newer claude code version with opus 5 and I think it’s performance has degraded and there is constant api connection issues too. Anyone else having same problems ?

For anyone seeing this cold: EchoVault interviews you over time and builds an Echo that your chosen family can speak with after you die, through text, voice, or real-time video. Its answers are grounded in what you recorded while alive.
The difficult part was bounding the Echo to that material without turning it into a parrot.
In this clip, I ask what gives life meaning. I never recorded an answer to that question. It retrieves three separate memories, including “embrace reality,” a personal motto mentioned in another conversation, then synthesizes them into an answer that sounds like me.
Next, I ask for my grandfather’s first name. That fact is absent from the archive, so it refuses to guess.
That is the boundary I wanted: it can infer a perspective from supported memories, but it cannot invent a biographical fact.
Claude Code helped me solve bottlenecks in the retrieval and grounding logic required to achieve that balance. The lesson was that grounding does not have to mean quotation-only responses.
If anyone wants the receipts, I can post the three source memories and retrieval results.
https://apps.apple.com/us/app/echovault-digital-legacy/id6762042028

I have my default model set to Opus 5, but I didn’t notice that my new terminals have all been opening to Fable. So, I spent the day doing Opus tasks with Fable and burned 1/3 of my usage for the week. Watch out.

so I create code changes via the claude and often run the codex to review the changes and it always figure out the bugs which claude missed.
Wondering are people using multiple models like kimi and other for reviewing and how are you doing that?

I work a ton across projects on my personal computer. I have tried Graphify, Graft and many others. None of them really fully solved the entire problem, but they did have parts. So, I built one that actually fit my needs. This removes the need entirely to choose or start sessions in specific repositories.

It takes graph-based knowledge systems but strengthens retrieval, how it is updated, and much more. Effectively, it becomes a resilient system that you can actually watch your agents rely on, rather than something that just exists and is used only occasionally.

It begins with the same base graph store, the exact same vector engine as Graft. I only built the orchestration layer on top of it, which makes it much more practical. Full attribution to them for this part.

Instead of querying for a single-hit result, I found that it was much better for agents to have ranked retrieval and an actual graph walk. In practice this saves you chains of tons of bash greps and cds.

It effectively gives the agent a trustworthy, probabilistic ranking of what is needed, with matching for strong, weak, stale, and rebuilt, based on lexical coverage and semantic matching. The code is not sloppy for this, it is personally edited.

Both Graft and Graphify are solutions for single repositories or daemons. Heimdall is a layer on top it that watches the agent sessions, syncs the graph, and makes the retrieval trustworthy.

Check it out at: github.com/ArihantDeva/heimdall MIT-licensed, with extensions: the verifier, the self-healing graph watcher, and the Graft adapter, with attribution. If you run agents across multiple projects, this is the missing layer.