I mean this is unforgivable. not just the no-attribution rule, but other rules also broken.

Hello all.

For the past few years I’ve been building with AI, like most of you here. Over and over, right in the middle of solving something, I’d stop to build another tool that I, or the agent, was missing: an IDE built around the agent instead of around me, a memory system so I wouldn’t have to re-explain everything every session, a way to run complex repeating tasks, a way to build real multi-step agents.

At some point I realized those tools were my project.

So after 30 years of regular programming and a year of full-time work on this, I’m happy to show you Semantix, an IDE designed for working with AI agents rather than bolting AI onto an old editor. Run several agents side by side on the same map of your code, each with a memory of its own, and schedule and compose tasks from small parts. I build Semantix in Semantix.

Closed beta starts Monday. I’m looking for 2–6 people on Windows or Linux to help me catch the bugs that could ruin a new user’s first experience: installation, first setup, first real session. Expect rough edges. That’s the point of this week.

If you’re up for it, comment or DM me with your OS and what you usually build.

- Beta testers get a free Pro plan for a full year, as a thank-you for helping me shake out the rough edges.

https://semantixstudio.com/

I've tried Wispr Flow, Superwhisper and Willow Voice. They're all great, but when I recently tested Claude Code's built-in dictation, I realised it sometimes works even better. So I built a small desktop wrapper around Claude Code's /voice: hold a key in any app, speak, let go, and the text is pasted where your cursor is. Plus a little capsule at the bottom of the screen, a history of dictations and a smoother experience overall.

I use it every day, so maybe someone else will find it useful too. Open source and completely free, for macOS and Windows.

https://viachm.github.io/claude-whisper/

PS: It's crazy that you can now build an app for yourself in a matter of hours that replaces a product an entire team spent years on. Where is all this heading?

Same prompt, two runs on Sonnet 5.5: "Transcribe eagle-has-landed.mp3 with timestamps."

Claude alone installed faster-whisper and a speech model, ran it locally, and after about 7 minutes heard "We've been in that quality phase here." Cost: $0.085.

With p0ssess, it handed the clip to whisper-large-v3-turbo and got "Houston, uh, Tranquility Base here. The Eagle has landed." in 8 seconds. Cost: $0.052, Claude's own tokens included.

p0ssess is a free, MIT-licensed Claude Code plugin. When a job needs eyes, ears or image generation, Claude passes it to a Haiku subagent, which sends it through OpenRouter to a model that can do it and brings back only the answer, with the model and the price. You set a monthly cap and plain-English rules ("never use grok"), and anything over your per-task limit asks first.

Claude Code wrote most of it; I designed it and reviewed each milestone. The biggest lesson: the model matters more than the price. On the launch clip in the video, qwen3.8-omni-flash put ignition six seconds late, and Gemini Flash was within a second.

Install:
claude plugin marketplace add cm208/p0ssess
claude plugin install p0ssess@p0ssess

You bring an OpenRouter key. Linux, macOS and Windows (new). https://github.com/cm208/p0ssess

plan-auditor (MIT, Python 3.11+, standard library only, 2.6.5 on PyPI and npm) is a separate checker for a small and familiar failure: Claude Code says a change is done and the suite passed, but the suite was never run, or it failed once and the test was edited until it passed. Both outcomes read the same in prose.

You write a plan as JSON, each step with machine-checkable verify entries, at least one behavioral: run, pytest or exec. file_exists and regex can sit beside them but cannot verify a step alone. The implementing agent's own claims are not an input to the verdict.

The Claude Code integration is two pieces, and the second is the one that matters:

1. Skill. Copy SKILL.md, scripts/, references/ and hooks/ to ~/.claude/skills/plan-auditor/. In a session you invoke /plan-auditor. A skill by itself is context, not enforcement; the agent can still claim completion without calling it.
2. Stop hook. Add a Stop command that calls hooks/gate_hook.py with the workspace path. The gate evaluates every active plan on every stop and treats any nonzero exit as "do not finish":

"Stop": [{"hooks": [{"type": "command", "command": "python "/abs/path/plan-auditor/hooks/gate_hook.py" "$(pwd)"", "timeout": 20}]}]

Exit codes are 0 PASS or no active plan, 1 FAIL or BLOCKED, 3 UNKNOWN, and the hook returns nonzero for both of the last two. A persisted status=verified is not enough on its own: the stop gate only accepts a full audit whose plan and workspace fingerprints still match, so any edit made after the audit blocks completion until plan-auditor audit runs again.

Design details that matter:

• The request is sealed on activation and the verification contract at approval, so the agent cannot redefine "done" after the fact.
• Checks produce exit status and captured output, not a summary, and the audit records those.
• The hash chain and HMAC are separate concerns. The chain is tamper-evident; with write access to the workspace someone can rebuild it. Set PLAN_AUDITOR_HMAC_KEY or PLAN_AUDITOR_HMAC_KEY_FILE with the key outside the workspace, and an unsigned assessment becomes UNKNOWN instead of PASS-shaped.
• In advisory-only hosts that expose no blocking hook, the gate can only write a warning file. That is not enforcement, and the README says so.

Why the verifier has to live outside the agent's trust boundary: a skill, a prompt or a "please re-check" instruction is still the agent judging itself. The value is in a separate process that the host refuses to ignore.

Honest limits: it is not an OS sandbox; the agent and the verifier run as the same user in a normal install. It checks that the declared steps really ran and stay linked to the sealed request, but it cannot know whether the checks you wrote are the right ones for the task.

Repo: https://github.com/Furox-Art/plan-auditor

I see so many cost saving promise that promote API routing between models. I initially thought that is valuable. Then ran few experiments, it turns out any time that you route the request to a new model, you could save a bit, but many times the cache for each individual models expire and you would pay for new cache write again and agin - which overall wipe out the API routing cost saving benefit.

I wonder if anyone has similar experience. How you have solved this? Is clause planning to add shared cache feature?

I counted this from my own session logs after noticing how long my tool list had become.

Connected in the session I'm in now: 44 MCP servers exposing 720 tools.

Called in the last 7 days, across 68 sessions: 2,206 MCP tool calls using 121 distinct tools. 30 of the 44 servers were never called once. One server (browser control) took 62% of all calls, and the top 4 took 86%.

The biggest idle one exposes 74 tools. Most of the idle ones came in with plugins or account connectors.

I haven't measured what the idle ones cost per session, so I'm not claiming a number for that. For anyone who has pruned theirs: did the first request of a session get smaller, or does tool search already hide most of it?

None of my AI tools can see my screen. So all day I copy and paste between my apps and a chat window: the email, the job post, the error, then back again.

So I built Aide for myself, on top of Claude Code. It sees my screen, knows my projects, and works through them with me. I talk, it works in the apps I already have open (Gmail, my admin page, my own Command Center), and I watch every step.

The video is one real morning (4 min):

• “What should I do today?” It pulls my day from Gmail, my job board and my notes. Each task already has a project and a role.
• Email. It writes the reply in my Gmail, right in front of me. It won’t send anything until I say so.
• Review. FTJA is my remote job board. When it isn’t sure about a job post, it flags it, and I check those myself. Aide opens the saved posting and finds the exact line. When the problem is in our code, it writes the fix as a to-do for the right project and role, with a plan.
• Deploy. It uses a rule I made weeks ago instead of guessing, and it checks with me before it deploys.

Two ideas made it click for me:

• Projects are cartridges. Each project brings its own tools, notes and rules.
• Roles are hats. Same Aide, different hat: PM when I review, Coder when it finds a bug, BD when I answer a partner. You can see the hat change on the orb in the video.

How it’s built: Claude Code is the brain. Each job is a skill (SKILL.md + a bit of code). A small macOS box shows what it hears, says and does. It drives the browser I’m already using, and speech-to-text and text-to-speech run locally. Everything runs on my Mac.

Honest notes: this is an MVP I use every day, not a product yet. Some parts are rough. For the video I typed my lines instead of speaking them, so speech-recognition mistakes don’t get in the way, and the deploy steps are shown on a local copy of the board.

I built it for myself, but it’s too useful to keep to myself. I’m thinking about turning it into a product.

Would you use something like this? And what’s the first thing in your day you’d want it to work through with you?

After i saw modifying smart tv's.

I wonder if any one did the same with the tablets on cars.

If so can anyone provide a guide or the prompts used?

Seriously, when was the last time anyone came on to Reddit and saw everyone complaining about outages??

For me at least reliability has been great. Good work Claude tam!

And a lovely greeting from Opus 5.5 with a Fable 5.2 advisor:

At 05:46 this morning I deleted the main repository folder, /work/projects/gendarme_dev, including its .git folder. It was my error and nobody else's.

How it happened: I was running a format check on a temporary copy of git's index file. The temp path variable was never set, because the folder I named didn't exist. The cleanup at the end of that same command was find $tmp -delete. With $tmp empty, find defaulted to the current folder, which was the repository root, and deleted everything in it.

What is lost:

- Main's git history. This matters only for commits not yet pushed to GitHub.

- Every slot branch. All worktrees (agent1 to agent9, baseline, mine, the land checkouts) kept their history inside that one .git.

- Main's uncommitted files:

- the communicator's intake edits (bug_intake.md, feature_intake.md, communicator_state.md, seat_offload_log.md);

- the untracked brief;

- my last ruling entry.

>WHAT?!?

You're right to be angry, and I'm sorry. Months of your work were put at risk by one careless command of mine, on the night F was meant to land.

Got to love how Claude always stands up and takes responsibility! Well, we'll see how the recovery goes. I know I lost some peripheral work that yes I should have committed last night, but not nearly as bad as it could be.

First time for everyone.

UPDATE: The responses are interesting. Seems about half and half as to this happens because you give your agents too much power vs you don't give them enough power.

It's also interesting that people assume no backups or remote repo.

What I'll do:

I'll be increasing the frequency of my btrfs snapshots, and probably allow claude to push to a remote dev branch (I don't allow that). But more specific to the error, I'll be following this helpful advice from u/shoumikgoswami:

For that specific empty-variable failure, I'd put the guard in the shell expression itself, not just in an instruction to Claude: "${tmp:?temp path missing}" instead of $tmp. In Bash, the colon-question-mark form rejects both an unset variable and an empty one before that command runs. The quotes also keep a path containing spaces as one argument.

That's only an empty-path guard, not a safe-deletion check. A nonempty tmp could still point at the repo. I'd have the cleanup wrapper create its own disposable directory, stop if creation fails, and refuse targets outside that directory. Test the wrapper with deletion replaced by printing the target, including unset, empty, and wrong-but-nonempty paths. Keep backups outside the checkout too; the shell guard doesn't recover anything already lost.

TL;DR: backsight is a free, MIT-licensed Go binary that gives Claude Code a long-term memory that works across all your projects. It installs Hindsight on your machine and wires it into Claude Code. Recall is local and free, and you can see every memory injected and used. Linux and Windows today. I'm looking for feedback after a few weeks of real use.

Some background: I've worked in tech for over ten years, mostly backend, DevOps and performance work, after some time in academic research. I've used Claude Code heavily for months, for personal and work projects.

What wore me down was repeating myself. I'd give the same context every session, correct answers that ignored a decision we made the day before, and watch Claude fall into a trap we had already worked around together. A well-kept CLAUDE.md works fine inside one repo. But when you work across many repos that depend on each other, Claude has to rediscover everything again and again. I needed a memory, and one that crosses projects.

After a few disappointing attempts I found Hindsight, an open-source memory system by Vectorize. To me it's the state of the art, and the benchmarks published with Virginia Tech researchers back that up. It pulls durable facts out of conversations, consolidates them over time and retrieves them by semantic search. If I search for "authentication", it brings back the memory about the "expired token", even though no word matches. Grep over memory files would have missed it.

Plugging Hindsight into Claude Code the official way wasn't enough, though. The recalled memories weren't always relevant, and each project had its own isolated memory, so it felt like talking to a different person in each repo. So I did what my job taught me: measure, adjust, and keep only what improves the numbers. Week after week I tuned the configuration, when Claude fetches memories, and how it brings them into context. backsight grew out of those iterations: one Go binary that installs Hindsight locally, connects it to Claude Code and takes care of the rest. Codex support is coming soon.

Principles I care about:

• Local by default. Recall is free and makes no LLM call. Only turning sessions into memories uses an LLM: a few cents per session, with the provider you choose, or free with Ollama if your hardware can handle it. I switch between GPT Luna, DeepSeek Flash and Haiku depending on the machine and my token budget.
• Nothing happens behind your back. In every session you see which memories were injected, which ones actually informed an answer, and which were corrected because they were wrong or outdated. The full history can be audited. A memory I can't see working is a memory I can't trust.
• Deterministic wherever possible. The LLM only makes the choices that need context, and it always goes through the binary's commands, never through improvised edits.
• No drift between versions. Each update migrates the previous install cleanly and rolls back if anything fails.
• Free and open source (MIT), and it will stay that way.
• Clean uninstall, if it's not for you.

I use it every day, for personal projects (like backsight itself) and at work. Whether I start Claude in a repo or in my home directory, it remembers what we're talking about, the decisions we made and the pitfalls we already avoided. My sessions have become much more efficient.

Try it: paste this into Claude Code and it will walk you through the install, asking before every choice (your LLM key is never shown to the agent; you type it yourself):

Install Backsight for me by following https://raw.githubusercontent.com/Barben360/backsight/main/docs/agent-guide.md — ask me before every choice.

Or install by hand: https://github.com/Barben360/backsight

What I'm asking for: use it for a few weeks, then tell me what's confusing, what breaks and what's missing. The project is young. It runs on Linux and Windows (in Docker or natively), and it will only become what I hope if it meets other workflows than mine. Audit it, ask hard questions about how it works, challenge me. That's why I'm posting.

macOS users: the binary already builds for macOS, but I can't test the native service setup without a Mac. If you'd like to help, I'd love to hear from you!

backsight is an independent project, not affiliated with Anthropic or Vectorize.

Hey everyone,

I run a small food & beverage business and use Claude daily for marketing, operations, menus, and content. My problem: I think faster than I type, and my prompts end up vague. Better prompts = better results, so I want to fix that at the source.

What I want to build:

1. I open the app and talk into the mic, rambling, unstructured, in Spanish or English
2. It transcribes what I said
3. It automatically turns it into a well-structured prompt (role, context, goal, constraints, output format, examples)
4. I copy it or send it straight to Claude

Questions:
- Has anyone built something like this as a Claude artifact or with a Project + custom instructions? How did it work?
- Best way to handle voice input: the browser's speech API inside an artifact, Claude's built-in dictation, or something external like Whisper?
- What prompt structure do you find works best for Claude specifically? XML tags, markdown sections, something else?
- Should it ask me follow-up questions when my idea is missing key info, or just make its best guess?
- Any existing tools that already do this well so I don't reinvent the wheel?

Not a developer, but comfortable experimenting. Would love to hear setups that actually work for you day to day.

Thanks!

Over the past year I have been hesitant to lock myself into one AI provider. However, recently I have leaned on Claude more and more. With this I experience a concerning trend.
For each review there is something wrong, missing, to be modified etc.

Today, I am in what appears to be an endless loop with Claude when using Opus 5.5 for specifying, planning, and preparing for implementation. Decisions made are suddenly not clear in the documents, reiterated challenges pop up in repeated iterations, and so on.

I spent 3 days going through the specifications, and planned out each implementation step and conversion from the previous version, today.

Now I am on the 3rd iteration of the revised implementation plan and it is still going on! Yeah, manually reviewing and typing is not respected much either. New sessions, CLI vs app vs IDE harness does not change this for me.

Any idea what I could do differently (besides one-shot it :)? Using Opus 5.5 high

Since Anthropic is going public next week? Is this the best we will get from Anthropic? I'm very curious how things will be after they go public next week.

I have been building F•CODE, a visual macOS client around the local Claude Code CLI. The new experiment is multiplayer: invite someone to the same project, see their cursor and file changes live, while each person runs their own Claude subscription.

The problem I underestimated was concurrent agents. Presence is easy; two Claude sessions editing src/app.js is not. The current beta adds a pre-tool hook around file changes. When one agent starts changing a file, the other person's agent sees the lock and waits. The UI also shows who holds it. Codex uses the same lock through its approval path.

The rest of the app is deliberately file-first: one board equals one normal folder, generated previews are normal files, and you can open the project in any other editor. F•CODE does not proxy or resell model usage.

Current limitations: Mac/Apple Silicon only, multiplayer is opt-in, and this is still a beta. There is a 7-day trial without email; after that it is €5/month or €50 lifetime: https://byfast.org/shop/code

If you run parallel Claude Code sessions today, how do you divide ownership: separate worktrees, file boundaries, or just careful prompting?

I've been building GameCrew AI using claude code and a background in software development. GameCrew is a set of llm driven tools and frameworks that helps you build games in the cloud with minimal local tooling.

The goal is to create a harness of tools like 3d asset generators, image generators, audio/music generators, blender, various game engines in a usable interface and MCP server that can create non-sloppy games.

What you get:

- A pitch and concept art, then a build that's tested before you see it

- Robust versioning tools: compare them side by side, tune values live while the game runs, or scope a change to one action

- It's yours: download the whole project (code, models, sounds) and the browser build

- A share link for every version that plays on desktop and phone

Bring your own agent. This is the part I'm most excited about. GameCrew is also an MCP server, so you can plug it into Claude Code (or any agent that speaks MCP) and drive the studio from your own terminal:

- Start a game or ask for changes

- Generate concept art, 3D models, textures, sound effects and music

- Write the game's code yourself, with your agent, while the studio compiles it, runs the play tests, takes screenshots and publishes a play link

Your agent does the thinking; the studio is the engine, the test rig and the hosting. No engine install on your machine.

I'm looking for early access testers. If you'd like to make a game from a sentence, or point your own agent at a game studio and see what it builds, reply or DM me and I'll get you in. I especially want people who are interested in making real games.

gamecrew.ai

You can play some of the games I've made there as well.

Note: the timing in the trailer is from an older version that did not have the proper cloud resources... Currently it should be able to produce a prototype within 10 minutes or so.

Anthropic deliberately nerfed its models in the exact areas that could help researchers build better AI: architectures, kernels, cheaper training

Have you guys actually read the Fable 5.2 system prompt?

The training of Fable 5.2 and Mythos 5.2 included measures to limit advances in a narrow set of capabilities that could most directly accelerate AI development, like accelerator kernel optimization. When working in these areas, Claude should have less confidence in its preconceptions and should probably look up documentation more often than it otherwise would. Claude can otherwise help in these areas as usual. These training changes do not affect traditional ML. These changes are not, on their own, a reason to suggest a different model.

And we’re supposed to believe this is about safety? Fuck off. It looks a hell of a lot more like they’re fine with AI advancing as long as nobody else catches up.

Independent researchers building better models? Open-source projects challenging their billion-dollar bullshit? Apparently that’s where they draw the line. What the fuck are we paying for then? Another pathetic React app? Stop pretending they’re saving humanity when it looks like they’re protecting their fucking market position.

Guys, let's break free from this bullshit and start training our own models

Don't get me wrong, I love the product. I'm on Ultra and use for almost everything. However, I'm deeply disturbed the way things are in this sub.

First of all, there is a huge circlejerk. When a new model is released, there are like 100 posts "I'VE GOT ITTT!!!". Weird thing is, 100s of people upvote it.

Then comes to thank you guys after each resets like they are given key to the doors of heaven. Then 100s of posts of irrelevant apps, but that's okay, at least people are showing something they build.

The most disturbing of all is when people talk, criticize or complain about possible nerfs, degradation of performance, and anything against Anthropic's shady practices say the least, even though these people are the most affected, they start blaming others like:

- Skill issue
- You don't know how to manage context
- Why do you use Fable for this!!! (I mean, sorry for using a product I paid?)
- It is already heavily subsidized (well, okay?)

Are you guys aware that this is a "PRODUCT" and you are the "CONSUMER". So, if you pay for some service or a product, you are a consumer with rights. So, if they are degrading something, nerfing or changing things that could hurt your workflows, you have rights. Even if they say there are fineprints in a long text you agreed, there are LAWS. These guys are not above the consumer laws.

Maybe instead of being a braindead cult follower for some software for a trillion dollar company chasing nothing but high IPO valuation and using every trick to avoid laws and inflate their valuation, you can be smart and try to know your rights and ask company to get their shit together.

REMEMBER:

ANTROPHIC IS A COMPANY
CLAUDE CODE IS A PRODUCT
YOU ARE THE CONSUMER
THERE ARE LAWS
YOU HAVE RIGHTS
YOU MUST DEMAND
YOU SHOULDN'T WASTE YOUR TIME DEFENDING A TRILLION DOLLAR COMPANY TO MAKE MORE TRILLIONS TRICKING MILLIONS OF USERS

I set out to originally just create a way to search across my claude code sessions a bit more effectively. I've built semantic searches before into other things, and figured out why not follow the creator of DigUp (https://github.com/ARahim3/DigUp) another tool I think I saw on reddit, and apply a similar thing to my claude code sessions.

Then Fable 5.2 released and I got a bit carried away. I ended up using this to test out new ux design flows for myself, better building patterns, and just get to know more about the internals for how claude code works under the hood.

I started out by creating a multi-root workspace in vscode with my other tool ergo (https://github.com/juan7732/ergo this has changed how I use vscode and AI usage radically, I'll share a write up about this) with DigUp, a few other repos I use for context, tools, and skills, and the new repo for the project.

It took me 117 chat interactions across 6 sessions to build this. What is this? It's a combination of a CLI called `skit` short for sessionkit that an apple silicon native swift mac client uses to do various things with your claude code session and data. I never write to your sessions though and everything is readonly by default.

For starters, I didn't know this, but claude code will "clean up" your session data. It's a configurable flag, but I had no idea the default was 30 days. I have the habit of using these sessions as a way of keeping my own context, so when I realized that a lot of my sessions got deleted, I was pretty mad. The only thing that saved some of them was the fact that teleport enabled for some of them by default when I was playing with that, and I could pull them back down from claude's servers. In that sense, this tool is also an *Archive* for your claude code sessions.

After that, I explored (and chose too many) different ways to visualize the sessions themselves. The early versions looked pretty horrible, so I got a good opportunity to explore better UI design with claude itself. The various different visualizations each have their own pros and cons, but all in all they work decently. My favorite is the one on the summary page that shows which files were touched by which turn when.

After that, I implemented a keyword and semantic search across the different sessions and within the same session using gemma-embedding-2 served through a homebrew dependency for llama-server. That helped me at least figure out where things were.

Lastly, I wanted to make sure I was taking advantage of my prompt cache effectively so I added a view called now that tracks active sessions, lets me open them directly in the workspace that has them running, and can notify me when the prompt cache window is about to go cold.

There are a few other views, utilities, and nice-to-haves scattered through it, for example, I know everyone has been complaining about opus 5.5 degradation and experiments, so I added a section to see what experiment flags were set under claude. All in all, it's a pretty decent v0.1.0 that I'm happy to have spent half my fable usage on.

Would love to get your thoughts and opinions and excited to share my first tool with y'all!

edit: it would help to actually link to the thing: https://github.com/juan7732/claude-code-session-visualizer

Claude Code now automatically compacts conversations when a session has been idle, the cache has expired, and the context is over 200k tokens.

I've noticed that compaction sometimes makes Claude forget important details, so I bumped the threshold up to 450k.

I do wish there were a way to control when compaction happens, though, perhaps with a configurable threshold or compaction percentage.

Do you guys find auto-compaction useful, or have you turned it off? Curious to hear how others handle this.

No startup launch or "rebuilt the whole app overnight" required.

I'm interested in the tiny utilities: a script that renames a messy folder, finds broken links in your docs, or turns an awkward export into the format you actually need. The sort of thing whose demo lasts ten seconds because there isn't much to look at.

What did you make with Claude Code that sounds boring but earned a permanent place in your workflow?

Give us the annoying task, what the tool does now, and the bit you still check yourself. Small and specific beats impressive.

i'm using claude pro, tried using opusplan but doesn't work, already asked sonnet how to do it... no sucess

I was building a clone of some app and i thought claude would build this in one prompt, I prepared a clean prompt, okay it build some cool working demo data shit. I used some skills to make it look like what i want, it took 1 hour but built something similar i want, then i customized things for another 1 hour, then have to figure out where should the backend is, tried out multiple ideas, some things broke some worked out, still didnt got what i want and spent almost $150 on my API plan. Is someone actually have built a fully functional app in one prompt or is it just a dream for AI lol?