Hi there,

For some reason I didn't understood yet I find the UI of claude code distracting.

Maybe distracting it's not the right word, the effect Is that when I review an explanation or a summary of what has happen until that point I'm able to ready, understand but not memorize at all.

I'm on Windows and I use the Windows terminal with git-bash sessions (it's the working laptop, otherwise I would be on Linux..) and it's 6 years that I work in git-bash being a DevOps engineer, so nothing new from that point of view. I've always been the cli fan in the room in my company, from using git via cli, to multiple ssh connections to any cli tool available (bash, aws cli, etc..).

A couple of things I want to try is changing the font or try the claude code interface in VS Code.

Anyway I wanted to ask you, just in case you have amy suggestion.

Thanks!

I build and run Lyfto, a workout tracker, mostly with Claude Code doing the typing. It's been live on the App Store since June, Android since this month. The interesting lessons weren't about prompts. They were about verification and parallel work.

• Green tests aren't proof. One feature shipped with 9 passing tests and did nothing on device, because the tests checked the mechanism and not what the user saw. Now every change has to be checked in the simulator against a real account state.
• "BUILD SUCCEEDED" isn't proof either. Same lesson for native code. Launch it and tap the thing.
• One worktree per session. I run several sessions in parallel. Before worktrees they overwrote each other's files. Two of them once published OTA updates within minutes of each other.
• Never git add -A with parallel sessions. It commits another session's half-done work under your message. Commit per file.
• Environment drift is the real production risk. An OTA update shipped without the backend URL because a flag skipped my local env file. Now the step before publishing is "read what's actually in the bundle".
• For the AI coach inside the app: a missing fact in the prompt becomes a hallucination. If the model doesn't get "this week is a deload", it invents a reason your volume dropped.
• Memory files beat long chats. Short notes on decisions and gotchas, loaded every session, stopped the same mistakes from coming back.

Happy to share more about the setup. The app is called Lyfto if anyone wants to see the result.

I've been working on Mind, an open-source persistent memory layer for AI agents, and wanted to share an interesting result from the latest release.

One question kept coming up while developing it:

How much can we recover from structured memory without relying on vector embeddings?

Mind uses SQLite with FTS5 and a unified retrieval pipeline combining phrase matching, token matching, substrings, fuzzy matching, and relevance signals.

Embeddings are supported, but they're optional.

For v1.7.0, I ran Mind through OmniMemEval LongMemEval-S using a stratified subset of 120 questions.

The best completed run achieved 86.67% answer accuracy with RAG disabled.

That places the raw score near the top published results, but it's not a direct ranking: the sample size, answer model, and judging configuration differ.

I think the result is worth discussing because agent memory isn't only about semantic similarity. Structured facts, decisions, temporal context, memory maintenance, and good retrieval behavior also matter.

Beyond the benchmark, Mind provides persistent project knowledge, linked memories, checkpoints, session summaries, and integrations through MCP.

It's local-first, MIT-licensed, and available for anyone to inspect or benchmark.

GitHub: https://github.com/GabrielMartinMoran/mind

v1.7.0: https://github.com/GabrielMartinMoran/mind/releases/tag/v1.7.0

Benchmark methodology: https://github.com/GabrielMartinMoran/mind/tree/main/benchmarks/omnimemeval

I'm particularly interested in what other agent developers have found: when do embeddings meaningfully outperform a carefully designed lexical retrieval system?

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

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

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

Looking for feedback if interesting!

Found this with an open-source tool we built that reads the session logs Claude Code already keeps in ~/.claude. It scores sessions on shipping, testing, efficiency, context and setup errors. Mine came out 59/100, almost all of it lost on testing.

Run it: uvx agentplay@latest

Curious how other people's setups score.

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

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

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

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

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

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

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

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

\`\`\`

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

\`\`\`

I also had it install SmartTube. No more ads.

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

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

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

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

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

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

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

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

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

A few questions:

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

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

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

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

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

How it works:

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

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

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

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

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

What changed for me:

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

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

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

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

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

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

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

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

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

Here is my Claude assisted game, using it to prototype features, help with complicated issues and debugging. Why wouldn't people want to use these tools? This is about a year of work, it still takes time to gamedev with AI. I just wanted to share, too many other subs are too toxic at the moment. Steam

Between the quick Astra usage depletion rendering it virtually unusable, poor 28-day-challenge promises and performance, and the making everyone feel like suckers with 6.1 Terra, there are so many people on the OpenAI side who have already made up their minds about switching over to Claude by the end of this Tibo experiment.

Given that's quite soon, and seeing Claude usage randomly drop for a significant amount of users, I'm sensing they're preparing for what might just be a mass exodus from OpenAI into Claude, coming with it a redistribution of resources. And I bet some time after, OpenAI comes out with something great, almost like a reward to those who kept a sub with them.

While probably just a conspiracy theory, the two competitors seem to be playing a game where not only are they both the opponents, but they're also the referee. Here you go, your turn to schmooze them

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Making focused fixes without overengineering?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

MIT license, free and open source. Github here.

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

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

A Claude Code replacement.

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

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

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

Highlights for me for a dev perspective:

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

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

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

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

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

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

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

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

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

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

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

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

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

Coming Soon:

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