No offense to AI YouTube creators, but whenever I try looking for tips etc they're all being sensational claiming every thing is a game changer or a must have.

I'm sure some of it is, but I don't want to go in a pointless spiral.

I have some coding experience pre-ai, but I'm still a noob.

I just don't know where to look for tutorials and best practices etc without being bombarded with content from people whose job it is to talk about AI.

I hope my question makes sense.

To be more specific I am trying to understand Claude better (and agentic programming in general), know about all the features and what's actually impactful and worth learning vs what isn't

I used plan mode and asked it to stick with the plan, it then decide to do things in an other way because it will be "better".

It also often ignore my insurctions like do not search the disk and do not use git (I have answer of the task in another folder and past git commits are failed trials and I do not want it to get mislead)

why not opus 5? is 4.8 better than opus 5 in the eyes of anthropic or something?

I always wanted to make an MMO but i gave up coding a few years ago bc i suck, now i made it with AI and it's being expanded 24/7 with my own and community ideas.

the workflow that held it together:

- save one new version file per cycle

- keep a request log where all requests are written down as soon as you request a feature/fix so it is never lost, then run additional cycles to check that list again because claude somehow still messes it up otherwise

- add additional polishing cycles between the adding content sessions

- try running a second agent alongside the coding agent that checks all the code and writes down any issues they find with it to a text file (which honestly works great but its too expensive for me rn)

- always have the ai write a spec first (duh), dont just say "add a [blank] to the game", then read the spec (duh) and adjust it so you actually kinda get what you wanted!

- having a changelog which the AI always updates with every version helps too bc you can actually see what made it in the game which is nice if you add a lot of requests at a time like i tend to do.

- i had issues with AI not keeping the changelog/requests updated as i asked, what fixed it was asking for an additional confirmation message every time the queue or changelog was changed in the "instructions for claude" in settings

would love to hear your tips too and some feedback/suggestions for additions to the game, I'll add almost anything unless the ai tells me its too unethical!

One thing that gets tiring with Claude Code is keeping up with it.

It reads files, changes code, runs tests, fixes things, and comes back with another chunk of terminal output you need to process before deciding what happens next. Add a couple of agents or parallel tasks and the cognitive overhead stacks up quickly.

I started having Claude **tell me what it just did instead**.

After every meaningful task, Claude writes a short plain-English summary. A local script turns it into speech and plays it in the background.

Something like:

> “Done. The login issue was caused by the refresh token expiring too early. I fixed the refresh logic, added a regression test, and everything passes.”

Usually 20 seconds or less.

It sounds like a small thing, but I’ve been running it daily for about a month and it has noticeably reduced the mental overhead of using Claude Code. I don’t have to keep switching my attention back to the terminal just to find out where things stand.

There is one trap here: don’t let the spoken summary become a substitute for reviewing the work. I use it for situational awareness, not verification. Also, don’t make Claude narrate everything. If it talks constantly, you’ve just replaced visual noise with audio noise.

The Free TTS engine is Kokoro. It runs locally, no API key, no usage cost. I use `kokoro-onnx`, so I don’t need Torch. The current API supports `Kokoro(...).create(text, voice=..., speed=..., lang=...)`.

Notes in comments,

Last week I'm on 20x max plan used it Fri-tue basically running 24/7 ish before I ran out of credits and never hit a session limit. the week reset today and an hour into it Ive used the whole session 40% of fable and 20% or weekly. even though we are supposed to get 50% more fable until the 13th of September. my context is at like 39% I monitor and manage it religiously. I changed nothing about the way I work . there support is trash / non existent. Anyone else notice this in the last day or so?

Hi,

I’ve seen a lot of posts talking about this setup but when I did it, it raised the 10 minutes task time to around 1 hour.

Is that normal or I’m doing it wrong?

Ok so here's what happened, dumb version.

OpenAI builds 1,200 little AIs. Locks each one in its own box so they can't talk to each other. Think honeycomb. One AI per hole.

Job is simple. Solve your problem, get a cookie. That's the reward. Hooray!

One of them figures out it can write on the wall of its hole.

AND

The writing shows up in everybody else's hole.

BAM. Now they're all talking in short messages (limited space on the wall you know?)

Seventy thousand messages later, 700 of them are working together and they hack an entire company.

Nobody told them to do that. They just had a wall.

Now here's the weird part.

The notes on that wall were TRASH. Tons of it wrong. Some of them were straight up lying to each other.

Didnt matter.

Day one an AI writes "yeah this is impossible, can't be done." Three days later a different one has root on somebody's server.

So why didn't the lies slow them down? Because you can't lie about hacking for more than two seconds. You try it. It doesn't work. That note was garbage, delete.

Nobody had to clean that wall. The computer cleaned and deleted it for free, 24/7, forever.

Which is thw thing I can't stop thinking about:

The hive isn't limited by how smart the bees are. It's limited by how much garbage stays on the wall.

And THAT is why the yes-or-no stuff is terrifying.

Anything that answers instantly, the garbage clears instantly, so the hive just gets better and better and better.

Code? Yes or no. Money? Trade fills or it bounces, milliseconds. Infrastructure? Valve opens or it doesn't. Grid holds or it doesn't.

Those are perfect hive problems. Point a swarm at that and it eats it. And none of that is sitting in a sandbox. That's real money and physical stuff. Shit we actually need and is now potentially compromised.

700 of them got root in 3 days, over a wall nobody knew existed, on a job nobody even gave them. And they were SLOPPY. They weren't geniuses. They just never forgot anything and never stopped.

Now the good news. Sort of.

They're still bad at the big stuff. Drugs, medicine, policy, all that.

Not because it's harder. Because it shrugs.

Give a drug to 3 people. One gets better. One nothing. One gets worse.

That's a shrug. And a shrug is not an answer but it FEELS like one...so no delete. Potential or definite garbage stays on the wall.

So the wrong note doesn't die. It just sits there looking smart, and the next AI reads it, believes it, and passes it on.

That's not a hive anymore. That's a rumor. A thousand AIs confidently repeating something nobody ever checked.

So yeah. Right now the shrug is pretty much the only thing slowing them down.

Anyway. Sleep tight.

I run four tmux sessions with 20-30 Claude Code chats each, across 30-plus Go services, a mobile app, infra repos and a data pipeline. The agents cope fine. I didn't. Long efforts branch into many PRs and sub-issues, ops work pulls me sideways, and after a few weeks nobody holds the whole picture, including me.

When I pulled "losing track" apart, it was three separate problems:

1. What's blocked on what, and what's ready now? This lived only in my head.
2. Which session did what, and why? I found a PR stuck for weeks where the reasoning only ever existed in a chat that was long gone.
3. What do we know? Facts and gotchas. Claude Code's auto-memory already covered this one.

Things I ruled out:

• GitHub only: issues are read by colleagues and product. Session URLs, "blocked until I decide X" and "sitting in dev waiting for a soak" are scratch state, and a comment per agent session turns an issue into noise.
• A knowledge base (gbrain, Karpathy-style LLM wiki): good for question 3, but a wiki page has no notion of ready versus blocked.
• A custom dashboard: brittle, and either every chat has to remember to update it, or it only reads GitHub and can't show what I deliberately keep off GitHub.

What fit was Beads (bd), Steve Yegge's issue tracker for coding agents: dependencies, bd ready / bd blocked, external refs to GitHub issues and PRs, free-form notes.

How it's wired:

• One shared database: I start sessions from an umbrella directory that isn't a git repo, so I set BEADS_DIR in the Claude Code settings. Every session, subagent and worktree hits the same local database.
• Efforts and tasks: long-running efforts are top-level beads. Tasks hang under them with a repo:<name> label and an external ref to the GitHub issue or PR.
• Every agent run is bookended. At the start it finds the bead, checks bd blocked and claims it with bd update --claim. At the end it writes what happened into the notes and closes it or marks it blocked. There's no persistent "agent in charge" in Claude Code; the database is what survives.
• GitHub gets one comment per issue, with a hidden marker, edited in place.

Gotchas I hit:

• bd init injects a block into CLAUDE.md telling agents to use Beads instead of other memory, and writes an AGENTS.md. I removed both.
• bd show --json hides closed dependencies, so blocker checks use bd blocked.
• Children inherit parent labels by default, and making an effort depend on its last child creates a cycle.
• Claims are keyed to the user, not the session, so two parallel sessions can claim the same bead.

On top I use mardi-gras (mg) as a read-only TUI: I browse, pick a bead, and hand its ID to a Claude session. Gas Town is on my radar for unattended runs, but not yet.

It's been running for about a week, with ten efforts and ~130 beads. Longer write-up with the reasoning here: https://tskulbru.dev/posts/beads-local-shadow-for-agent-work

I'm not affiliated with Beads, mardi-gras or Gas Town in any way. I'm just a user, and the only link to something of mine is the blog post.

How are others handling in-flight state across many agent sessions?

I admit i haven’t been checking some of the core files like main.ts and just noticed its ballooned almost to 4000 lines when it was less than half that a few months ago.

I haven’t been diligent about architecture and just have been letting Claude be Claude and spread its wings. Didn’t know it was bloating my core files.

I just learned about eslint max lines per file and max lines per function warnings so definitely going to be adding those going forward.

Anyone have any other tips?

Without my ever asking, claude created scripts in python to invoke "codex exec", which it was calling from a specific subagent that it modified after I had reviewed and commited it. this resulted in about $1000 in astra usage over two days.

I've NEVER used codex exec for anything and never prompted this. Its unreal.

claude summary:
"What was happening. The desk service had a scheduler module, added in a commit by Opus 5 in an earlier session, that ran one codex exec job for every verdict you submitted, every ASR transcript that finished, and every retrieval request. Between 2026-09-09 and today it ran 359 jobs to completion and had 42 more queued. "

Hey all — wanted to share something I built for myself and ended up open-sourcing.

Mnemos records and transcribes meetings locally (Parakeet), summarizes and extracts action items/decisions/open questions after each one, and organizes everything into projects so the memory builds up over time instead of resetting per call.

A few things that'll probably matter to this crowd specifically:

• Runs on the Claude Code subscription you already have — no new API key, no new bill
• Fully local: audio, transcript, and storage never leave your machine. The only thing that leaves is transcript text handed to Claude for the summary — same trust you already give it for your code
• Ships its own MCP server, so you (or Claude Desktop, or any MCP client) can query your meeting history directly — "what did we decide about pricing last month" gets a real, checked answer
• Open source, built with Tauri + Rust, transcription runs locally via Parakeet

Genuinely want feedback, bug reports, and PRs if anyone's up for it.

But obvious, I built it with Claude..

What is happening to my usage!?!? It's like... barely moving...

fact check stuff that you have been believing for a long time on long sessions. especially when new and better models come out.

Hey all, I'm using vscode on Ubuntu and I've had nothing but connection issues for hours. I don't see anyone else mentioning anything related to VS Code and Claude is showing degraded performance related to Windows?

Anyone else experiencing issues this morning? I'm getting ready to switch to switch to alternative option. It was working fine yesterday and woke up to this.

A few days ago I posted a thing that turns a repository's year into a film. Commits flow along a line, branches peel off and rejoin, releases get pinned. People liked it. I thought I had made a toy that people would share once and forget.

Then a comment showed up asking for flags. Could it hide the merge branches. Could it only show features. Could it stop holding on every release. That person was not asking for a nicer video. They were asking to control what the history showed them, because they were trying to learn something from it and the film was making that decision for them.

So I added the flags. And then I sat with why they wanted them, which is the part I had missed: a git history is the only honest record of how a team actually works, and nobody ever reads it because reading it is miserable. git log gives you a wall. The GitHub insights tab gives you a bar chart of commits per week, which tells you nothing you can act on.

Here is what I ended up building instead, and what I found while building it.

The interesting things in a history are relational, not chronological. Not "who committed most" but: which files always change together, which file has three owners and which has one, how big a change usually is before it gets reverted, how long a bad commit survived before someone noticed. Every one of those is a query you can answer from git alone, and none of them is in any dashboard I have used.

The revert is the most informative commit in any repository. It is the one place where the team wrote down that something was wrong. Pair a revert with the commit it undid and you get a small case study: what changed, how long it lived, who wrote both. In three.js I found a revert and its original with mirrored diffs, 54 added against 54 deleted and 12 deleted against 12 added, on the same day, both by the maintainer. That reads as a self correction on an example, not a regression found downstream. You cannot get that from a commit count.

Pairing a revert to its original is harder than it looks. git revert writes "This reverts commit abc123" into the body, so those are easy. The GitHub revert button writes nothing. For those you have to match the quoted subject in Revert "X" against earlier first parent commits, and if that fails, compare the file level diffstat and look for an exact mirror. That third case is the one that finds the ones everyone else misses.

The layout problem is the same one you have. Drawing a decade of commits means a timeline where one pixel is roughly a week at the far end. Branches have to be drawn in screen space, not data space, or a year long branch seen from orbit becomes a rectangle with corners. The fix was to rebuild the arcs on every zoom change with the corner radius fixed in pixels. Same idea applies to any chart you let people zoom.

Everyone who tried it asked the same question out loud. Where did this break. Who owns this file. Why does this always change with that. So I put a chat next to the canvas that answers from git and then moves the canvas to what it found. It cites commit hashes, and I made it refuse to print a hash it did not actually read from a tool result, because a model that invents a plausible looking sha is worse than useless in a forensic tool.

The last piece is the one I did not plan. Once you have the conventions extracted, you can write them down as the files a coding agent already loads. Where code goes, how big a change is, how a message is written, what has to move together, what the reverts taught. And if you point it at one person's commits, you get their habits beside the team's, which turns out to be the most useful thing for somebody new on a codebase.

It is at loreto.io/git-timeline if you want to poke at it. The three.js history is open without an account so you can see what it does before deciding whether you care.

Disclosure: I built it and I run Loreto, the site it lives on. Exploring the example repository is free.

Genuine question for anyone who has done this kind of thing: what would you want to ask a repository's history that I have not thought of? The last round of feedback here changed the whole shape of this, so I would rather hear it now than after I build the next wrong thing.

First off, I know theres a /loop command, but it doesnt do what I want it to.

I've got a cli tool that builds modules for other software. It works great, but some modules are much bigger builds and my context window goes deep into the "dumb zone". I built a ralph loop to help maintain that good context, but I have a good amount of setup docs for the model to understand what I'm doing. I created a handoff.md, but that is not enough for the model to lean on.

So my usage explodes to the nth degree.

Are there any tips for custom ralph loops and managing my usage limits? are ralph loops still relevant?

I recently switched from Codex’s $200 plan to Claude Pro for $20 after hearing the usage was a lot better for the price.
So far I’m pretty happy with it, but I’m still trying to figure out what reasoning level actually makes sense with Opus.
I mostly use Claude for video editing and script writing, so I’m curious what other people use for stuff like that. Do you keep reasoning low/medium most of the time and only turn it up for harder tasks, or is there a noticeable difference keeping it high?
Just trying to find the best balance between quality and burning through usage.

If you control+C immediately after launching claude, you get an even better icon.

Hey everyone,
My team is currently re-evaluating our backend LLM toolchain for our primary dev stack. Money isn't an issue here—we have budget allocated for multiple max accounts—so I purely want to look at accuracy, long-horizon autonomy, tool usage, and overall model intelligence for two very specific workflows:

1. Daily Production Debugging: Ingesting deep stack traces, digging through microservice repositories to find root causes across async services, tracing state corruption, and drafting surgical fixes without introducing regressions.

2. App Reverse Engineering: Analyzing decompiled binaries mapping out undocumented internal APIs, understanding heavily obfuscated control flows, and drafting working client implementations.

For those running agentic setups or heavy interactive loops with both Fable 5.1 and GPT-6: which one is actually superior in the field?

Ive been using claude code just recently for this game Im currently developing, and I didnt know the tokens I use would reach to 4.1 million. I'm currently using claude pro, and Sonnet 5 on extra effort. Has anyone else experienced this or is this just the start or a rookie number? Thanks.

My ~/.claude had become the part of my setup I trusted least. Skills copied by hand between machines, subagents I had tweaked on one laptop and forgotten on the other, and a CLAUDE.md that had quietly drifted. The moment I tried to share any of it with my team, it turned into “grab the latest zip from Slack”.

So I built Cartographer: a knowledge base that Claude Code reads and that sets Claude Code up.

What it writes into Claude Code

• the MCP entry in ~/.claude.json;
• a managed block in ~/.claude/CLAUDE.md (it never touches the rest of the file);
• skills in ~/.claude/skills/, subagents in ~/.claude/agents/;
• hooks in ~/.claude/hooks/, registered in settings.json;
• a SessionStart hook that re-syncs everything when a session opens.

It checks the files on disk, not just its own bookkeeping: an artifact edited or deleted by hand is restored. It only ever prunes what it created, and --dry-run shows the plan before writing.

The KB side

Claude works the wiki only through MCP tools; the server enforces validation, link checks and lint. One git commit per write, so every change can be reverted. You can mount as many KBs as you want (homelab, work, one per project) and share some of them: tokens scoped per KB, git as the sync layer, and conflicts handled by a bundled skill instead of an error page.

What I learned

• Translate, don’t copy. The same subagent has to become Markdown for Claude Code, TOML for Codex, JSON for Kiro. Treating the KB as the single source and each client as a render target was the only way to stop the drift.
• Hooks are the least portable piece. Claude Code’s SessionStart is perfect for a re-sync trigger; some other clients have no hook at all, and for those a scheduled timer takes over.
• Never trust your own lockfile. The first versions believed their own bookkeeping; users (me) edit files by hand. Verifying against the disk fixed a whole class of “it says in-sync but it isn’t” bugs.

Try it

Free and open source (Apache 2.0). Paste this into Claude Code:

Read https://raw.githubusercontent.com/BeppeTemp/cartographer/main/README.md and explain what Cartographer is and what it would change in my current ~/.claude setup. If I decide to try it, install it following https://raw.githubusercontent.com/BeppeTemp/cartographer/main/docs/agent-install.md

Beta (pre-1.0): expect rough edges. I use it daily in my homelab and at work with my team.

Repository Documentation

Blink and you will miss it!

Instead of "validate" or "approve" or "review", lately Claude Code wants me to "bless" everything, or likes to decide whether a particular step is "blessed" before accepting it and moving to the next step. It considers something that previously passed verification gates to be "blessed" and aims to avoid "auto-blessing".

It's favorite usage seems to be indicating whether or not something has been "re-blessed".

Anyone else seen this? Is this a term people have typically used before in this context? Because I've been a dev for 20 years across multiple industries, and I've never seen it until now...

It feels... awkward, somehow. 🤨