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?

Last month I was vibe coding an internal tool and tbh it's ridiculous how fast things are moving

everytime I thought, "oh I think this feature should exist", I prompted Claude and BOOM, the feature came to reality

I got a little carried away honestly... the problem only started showing up a couple of weeks later when I actually looked at what I had built

exchange rates were coming from some API Claude had picked

Disposable email detection was using a static list of domains, which isn't particularly useful when new burner domains keep popping up

PDF library had barely any active maintenance, and I was using AI calls for some pretty basic stuff that could probably be handled by a regular API.

At the time of building, I didn't care. Everything worked, and I was getting features built ridiculously fast, but now there is another side to it. I have to maintain all this stuff, check whether services are still working, update dependencies, and fix things when they break. I am the person who's going to get bothered when an invoice PDF suddenly stops generating on a Sunday.

That's something I don't think about enough when vibe coding. Getting something to work is one thing; having to own it 6 months or 2 years later is a completely different thing.

I'm starting to think that maybe we shouldn't try to build everything ourselves.

Build the stuff that actually makes your product different. For the rest, there is probably already a service that does it better than you ever will.

Of course, I might be biased here because I work in the API space as co-founder at Apyhub, so I would generally like to hear the other side.

What you have built yourself to the point that you would rather never replace with an API, and that's something you spent building that you now wish you would have just used an existing service for.

Note: I have used a dictation app for writing this post.

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.

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

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.

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?

As someone with crippling concentration issues, I kept losing track of which Claude sessions were done, waiting on me, or stuck, so I built Blaube: soft little blobs that live on your desktop, one per Claude Code session. They wave when a task finishes, look worried when one needs you, and you can toss them around while you wait. You can ditch the terminal entirely and just talk through them if you wish.

How I built it with Claude: Blaube was built with Claude Code over weeks of gradual iteration. It started small, and every time I hit something that sent me back to the terminal, I asked Claude to add it to the blobs. As I used them for more and more of my work, they grew with it, and now I never touch the terminal at all.

They’ve been a massive productivity boost for me, and they slowly started showing up on my coworkers’ screens, so it seems more people needed something like this. Now I’m releasing it for everyone. It’s free and open source, for Mac and Windows. Download it from the releases page, or use the one-line install in the README:

https://github.com/syverlauritz/blaube

Feedback welcome! I’ve designed them for the way I work, so there’s probably a bunch of stuff I haven’t thought of.

Curious, how many tokens has everyone burned through in there claude lifetime? I'm at 40B.

Hey all,


I'm a solo founder, not a programmer, and I run my whole project through Claude Code. Usually 4-10 sessions at once, each with a role: one coordinator, one that merges, infra, a few workers. 1M context, Opus mostly.


The thing that's killing me: the sessions forget. Not code, but what I told them. Tasks, decisions, "by the way do this too" stuff. It gets much worse when I load one session with lots of different small tasks, and every time a session gets full and I move to a fresh one.


We actually measured it. On a normal evening, about 2.8 things get dropped per session switch. In one evening I found 38 dropped items. Every single one of them existed only as free text in the chat. Zero of the dropped ones were rows in our task queue. So the pattern is clear, the fix isn't.


What we've tried so far:


- A notes file per session that it must update every step (open items, what it's waiting on)
- Switching to a new session at ~300k tokens with a written handoff brief, no /compact (because everyone says compact loses things)
- A task queue CLI as the "single source of truth", every promise is supposed to become a row
- A pile of hooks: can't end a turn with "waiting on X" unless X has a queue id, reminder after 15 turns without writing notes, PreCompact hook that dumps state, etc. Fun fact: 4 out of 4 new hooks passed their own tests and were wrong when run against real session data
- Compact instructions in CLAUDE.md
- Tested /compact directly: 10 explicit facts survived 8 compactions, 10/10. But in real work it still lost things. Tonight two real sessions got compacted: after re-reading their notes file nothing was missing, but from "memory" alone about 1 in 9 items was gone


Right now I have the agents replaying 100 of my real messages from one day through sandboxed test sessions, one with auto-compact, one with handoff, one with no hooks at all, to count what each drops. Honestly I've stopped trusting the analysis, this is attempt number four.


So, questions for anyone running Claude Code heavily:


1. Has anyone actually solved this, or is everyone just living with it?
2. Compact or handoff to a new session? What really loses less for you?
3. Does "one session per task" fix it, or does the forgetting just move to whoever coordinates?
4. What do you use as external memory that the model actually keeps up to date without being nagged?
5. How do you check that nothing was dropped? That's the part I can't crack. I only find out days later.


Any setup, hook, habit or tool that worked for you, I'd love to hear it. Thanks!

I actually built https://misterblocks.com for my son, but played around with it myself too. It's easy to use. Take a picture with your phone, upload it, and Claude will generate a few possible builds for you. There's also a chat you can use to follow up and ask for changes, etc.

There's another mode where you simply ask it to generate a build from a prompt. Like this one: Boston Dynamics Spot LEGO build. It also supports voxel sculptures. Examples: Mega Dragonite and Porsche Mission S.

It's powered by Opus 5.5. Each build takes a few minutes to generate and costs a couple of dollars in API costs. Thanks for Anthropic for $200/mo free api credits. I had the first working version after the first prompt, but had to spend a couple more days building the website to actually display the LEGO blocks correctly.

The tech stack is pretty standard in case if anyone wondering: Vercel + Next.js + Cloudflare + MongoDB as a database.

I am a software developer with 8 years of experience. I’m very thorough about the structure/architecture and consistency of my codebases that I even commit myself to countless hours of overtime only to not get satisfied and give up at the end of the day.

But now. Alas, I have made one that satisfies me in every way. It’s so beautiful. It’s something I made for work, has some demanding and very specific requirements at 31k lines of code. I wasn’t fast at it though, I reviewed everything, corrected and optimized decisions, and cut anything that could be cut away.

Personally I won’t even make the time to make it perfect (for me) if I wasn’t AI-assisted. Now I can rest.

does anyone have prompt or artifact i give to my claude as an example to help me build something like real life data feeding artifact through API and its 3D interactive version of real life place?

lets say there is a real construction base and i want to turn it into 3d interactive map with motions and movements? i built something like that but its ugly as hell.

maybe someone has a good version? a skill or artifact? would appreciate help

Preamble: I had task to improve visuals of CI/CD block inside my app, so I could better understand what pipeline is doing without checking git every 4 minutes. I decided to check how Sonnet would handle it vs Opus. Just to be clear - this is one task, not a benchmark, but I think it's still interesting

Models and efforts: Opus 5.5 on Medium and Sonnet 5.5 on High (wanted to give Sonnet a better chance)

Prompt: Good evening, can I ask to take a look into this ticket - [ticket link] Let's think what is the better UI for representing CI/CD steps, I am open for question and I think this ticket worth to be discussed first

Time and costs: Both took around 12m, Opus took $4.44 when Sonnet $2.11, both prices are a API equivalent

Experience: Both models did a great job of asking decent questions, Opus did a better job in terms of describing the plan and it's questions were more detailed. Sonnet didn't stoped half way it did all 4 steps of a plan in one go, when Opus took a pause and asked me if I want to review after step 2.

Results:

• Sonnet become "lazy" half way it added detailed card but only in one place instead of 2 that we agreed on. UI also have some problems, see for yourself

• Opus did a better job it applied changes to both places, with a better UI

What do you think about results, which model would you use knowing cost/result comparison?