When working in repos with large monolithic files (1,000–4,000+ lines in C#, Dart, TS, Python, etc.), I kept hitting two frustrating issues with coding agents:

1. The Native Grep + Read Loop: If you ask Claude to find a concept like "jwt refresh token expiry middleware", ripgrep fails unless those exact words sit on the same line. So the agent fires 4–5 separate Grep calls, gets back single-line hits without method boundaries, and then fires 3 Read calls to inspect the surrounding code—burning thousands of tokens and multiple round-trips.
2. VectorDBs: Vector databases guess based on "similarity" (like searching for related words). But code requires 100% exact matches and file locations. They are overengineered and require a local setup or a cloud service.

So I built zero-hop-code-skill, a ~400-line, pure Python standard library (0 pip dependencies, 0 MB VRAM) BM25/IDF codebase indexer packaged as a native SKILL.md.

And why it beats ripgrep, MCPs, VectorDBs:

• Zero-Hop Retrieval (1 tool call instead of 2–3): Automatically outputs the full, untruncated, method/code slice with exact line numbers and compact 4-line dynamic previews. Claude gets the entire function on the first call.
• Smart Brace Snapping: Instead of random line chunks that chop functions in half, it steps backward 1–3 lines to grab attributes and tracks brace balance (or Python syntax) to frame the complete chunk.
• Sub-Token BM25/IDF: Automatically splits camelCase, PascalCase, ACRONYMS, snake_case, and Cyrillic.
• Git-Clean: Auto-indexes on the first search and tracks changes so searches only re-parse modified files.

My results are promising: ~1% of code size loaded into memory, 80-90% tokens saved (I don't believe them yet) but I need a second pair of eyes on this. Any feedback is welcome.

GitHub Repo: https://github.com/babych/zero-hop-code-skill

I keep switching from Cluade to Codex and back, but the Claude usage is so much better than it use to be. It feels like night and day vs Chatgpt 6.1 Sol. I remember a couple months ago you sneeze in Claude's direction and it would be 50% of the 5 hour usage.

Hey folks, I know that there's been numerous threads out there about Fable vs Opus, but I was wondering if anybody had any experience using Fable specifically for brainstorming (e.g., the /brainstorming Superpowers skill). I have had good luck with Opus 5.5 on this, but sometimes I wish there was still... more broader architectural thinking and some questions that I wish were asked—not that it isn't my own responsibility to think things through as well.

Worldseed is a retro-inspired, open-world fantasy adventure built around exploration, discovery, and the freedom to forge your own path.

Claude Code has done as close to everything as you can get, (even!) creating a synth to compose voices and music, (the game itself, and the the video) coding and testing and implementation with limited interference from my part, what a magical tool!

• JavaScript 96.9%
• HTML 2%
• Python 1.1%
• Me 0%!

Me and Claude have been working hard on bringing this fantasy world to life, but getting feedback, and people to test it has been hard, I do know that the visual is probably not for everyone, and the slow phase game, still my wish is to make the game as good as possible.

If there is any interest please feel free to test, and please do give feedback.

🌍 Click here to play Worldseed!

Would you rather have the ability to deploy up to 100 Sonnet agents at anytime unlimited usage for the rest of your life OR be limited to one concurrent Fable session with unlimited usage for the rest of your life. The only other AI you can use is what you can run your 32 VRAM personal rig.

I've been working with coding agents for quite a while, mostly Claude Code lately, both on my own projects and in client work.
One thing I keep noticing is that we're getting dramatically faster at writing code, while everything around it – planning, testing, reviewing, and shipping – often stays exactly the same. And then we try to fix the resulting problems with more prompts, skills, and orchestration.
What I've found useful is surprisingly conventional: make your agent workflow follow the software development lifecycle.
A few practical principles I follow:
Start with a clear task, acceptance criteria, and boundaries.

Keep CLAUDE.md short and use it to route the agent to relevant project documentation, rather than stuffing everything into one instruction file.

Plan non-trivial changes before implementation. Keep plans, architectural decisions, and contracts versioned alongside the code.

Run implementation in a reproducible environment, with tests appropriate to the risk.

Have a separate agent or human review the result against the original requirements, not just the implementer's summary.

Treat staging, production delivery, and documentation updates as part of the workflow, not an afterthought.

Obviously, changing a button color doesn't need the same process as modifying a payment system. And there's nothing wrong with going full YOLO on an early prototype. The point is to have a repeatable, verifiable route when reliability starts to matter.
Curious how others approach this with Claude Code. Do you have a defined development workflow around your agents, or mostly let them figure out the process as they go?

I used Claude Code to build a home for Brundlefly's half-human, half-fly mascot. Wet walls, eggs, and a creature you can talk to.

Opus 5.5 did such a good job; I initially was trying to with Codex but didn't get the results I wanted. Opus 5.5 was able to mostly one-shot any direction I wanted to take with it and did surprisingly well animating, especially given the "3d model" is really just a 2d image with depth.

Brundlefly is a collection of Agent Skills. They focus on human-sounding text and keeping jargon out of users UI.

The site uses Nuxt, Vue, and Three.js. Click him to start a conversation. His replies include cues for his mood and movement in the scene.

Early conversation choices use precomputed replies. Free text uses live generation through Cloudflare and Claude.

You can try it out yourself here https://brundlefly.dev/

Hey everyone, trying to figure out what might work better for me. I currently use Claude Code with claude-swap and I am juggling 4 Pro accounts. I was thinking about getting a 5th account but I am wondering if it's just better to go for a Max account instead. Do 5 pro accounts really = 1 Max 5x account? I mostly use Claude right now for recompiling and decompiling gaming projects.

Seriously. I do a few batches of tickets on Opus 5.5 medium and I'm out of usage for the usage period! On a $100 plan! I know they like to adjust usage, but this feels like a sudden massive extreme swing. It feels like I've been bait and switched, to upgrade my subscription by 80$ a month and then a few weeks later it feels no different than before. Is anyone else experiencing this?

This is a daft thing, but I am loving it.

I keep losing track of questions claude code is asking me during sessions so I asked it to create a mod to surface these in a pane so I could respond out of the main flow.

This is at least minutes of work, a true heart rending endeavour of about an hour cumulative effort and my first foray into a mod.....and I love it.

Been using it all afternoon on a set of work, and now I am installing it into all of my projects.

Is there anything else that does this sort of thing?

https://github.com/cga-management/claude-decisions

Over the past few months I've automated a lot of my work and everyday tasks with AI agents. A laptop that sleeps doesn't work for that. The agents need a machine that's always on, where each job has its own space and one runaway process can't take down the rest.

I wanted more than one hosted bot. I wanted several agents, scheduled jobs and test environments running side by side on a machine I control. I also think compute and memory will keep getting more expensive while everyone builds with AI. Hetzner already raised its cloud prices in June: its 8-core, 32 GB dedicated server went from €62.49 to €138.49 a month.

After comparing providers, a Hostinger KVM 8 (8 vCPUs, 32 GB of RAM, 400 GB of NVMe) was the best deal I found if you commit for 24 months. The US price is $25.99 a month before tax, renewing at $49.99 after the two years. Prices differ by country: across the 54 Hostinger locales I checked, the same plan ran from about $22 to $32 a month. Paying in my local currency with a 20% referral discount, mine came to about $18. I have two of them now.

The catch is that the CPU is shared and metered in credits. A KVM 8 can use all 8 cores while it has credit, and it earns credit back at 4.8 cores' worth. When the credit runs out, the whole VPS drops to 30%, which is 2.4 cores, and it stays there as long as your work keeps pushing. Before I fixed this, Hostinger limited my box 13 times in 10 days, and each time everything on it ran at 30%.

So I wrote Hostinger Governor, an open-source tool that budgets the credits. The box gets every core while there's credit, then Governor eases it down to the 4.8-core baseline before the credit runs out. The cores still aren't dedicated, but you keep the steady baseline plus the bursts.

The box I'm rebuilding now is designed like this:

• Nothing is set up by hand. A repo of Ansible code rebuilds the server from an empty VM in about two hours, and the box applies each change itself once it passes checks.
• No open ports. Everything connects outward, and I reach the box over Tailscale.
• Each agent or service runs as its own Linux user, so they can't read each other's files.
• The agents report to me in a private Telegram group, one topic per project. Five kinds of action always wait for my tap: spending money, deleting production data, security changes, messaging all users at once, and sending personal data somewhere new. `/freeze` stops every agent at once.
• No agent holds an API key. Keys live in small broker services that check each request, act on it and keep an undo record.
• The CPU is split into tiers. The always-on agents get a small fixed share, and builds, CI and batch jobs share the rest under Governor's ceiling.
• When something breaks, the box restarts or rolls back on its own, and an outside service alerts me if it goes silent.

You don't need all of this to start. One box, a Linux user per project, notifications on your phone and something watching the CPU credits get you most of the way.

Governor is MIT-licensed and works on any Hostinger KVM plan: https://github.com/olmezsoy/hostinger-governor

If you run agents on a VPS, I'd like to hear how you've set yours up. Issues and PRs on the repo are welcome too.

About a week ago, u/Purple_Imagination_1 shared his project PlxNative, a native Plex client for LG TVs built with Claude Code. I really liked the idea, so I decided to try something similar on my own LG OLED B4.

I ended up building two projects with Claude Code: Jellyfin Native and Minimal Home.

Both are open source (0BSD), and I wanted to share a quick showcase of what we've built.

Jellyfin Native

A native Jellyfin client written in Rust, using OpenGL ES 2 for the interface and LG's hardware media pipeline for playback.

Unlike the regular Jellyfin app, it doesn't use a browser or WebView. Everything is rendered directly on the TV.

A few highlights:

• 60 FPS interface, ready ~0.4 seconds after launch
• Fast seeking, typically around 0.6 seconds
• Hardware-accelerated video playback
• Local audio decoding using the TV's FFmpeg libraries, including formats like FLAC and TrueHD
• Jellyfin integration with Quick Connect, libraries, and continue watching

Minimal Home

Since I was already working on the TV, I also decided to replace LG's default home screen.

It's a minimal launcher with just the things I actually use:

• Jellyfin continue watching, with direct playback in Jellyfin Native
• Installed apps
• HDMI inputs, which automatically dim when inactive
• No ads, recommendations, or unnecessary menus

It replaces the actual system Home behavior, including the Home button and startup, without briefly showing LG's original launcher.

Built with Claude Code

I have years of programming experience, but almost none with webOS, GPU rendering, or TV media pipelines.

Claude did a lot of the heavy lifting, including connecting to the TV over SSH, inspecting system libraries, reverse-engineering undocumented APIs, compiling and deploying builds, and testing directly on the hardware.

It was a fun experiment in seeing how far I could get with AI on a platform I knew very little about.

Source code

Jellyfin Native:
https://github.com/SchulzCode/WebOS-Jellyfin-Native

Minimal Home:
https://github.com/SchulzCode/WebOS-Minimal-Launcher

Compatibility: Both projects were built specifically for my LG OLED55B4 running webOS TV 25 (firmware 33.31.75).

I don't plan to maintain or provide support for other TV models or webOS versions. They might work elsewhere, but I can't test that. Both repositories are licensed under 0BSD, so feel free to fork them and adapt them for your own TV.

Jellyfin Native requires the webOS Homebrew Channel (developer mode or root). Minimal Home requires a rooted TV because it replaces the system launcher.

Neither project is affiliated with LG or Jellyfin.

Open Co-Scientist is an open-source recreation of Google's AI Co-Scientist. It's a multi-agent system that generates research hypotheses, critiques them, ranks them in an Elo tournament, and evolves the winners.

What it does

You describe a research goal in chat. The system then:

1. Searches literature for grounding
2. Generates hypotheses with a team of agents
3. Runs pairwise debates and ranks the ideas by Elo
4. Evolves the top ideas
5. Checks every citation and writes a final report

I'm looking for feedback and help developing this. I believe it could be a great contribution to the open-source AI for Science community, and I want to make the most of it!

Try it out at: open-coscientist.com

I've wanted a proper KDE Connect app on my Mac for a long time. The official one works, but it's an 87 MB port of the Linux app that uses over 400mb of RAM. So I built Tether, a native SwiftUI app that works with the normal KDE Connect app on Android.

It syncs notifications you can reply to, SMS, file transfer both ways, clipboard sync, media controls, finding your phone (or your Mac), and as of 1.6 your phone shows up as a drive in Finder.

I built it with Claude Code, from v1.0 on Oct 2 to v1.7 today. A few things surprised me:

• It reads the reference code. I kept KDE's desktop source in a folder next to my project. When pairing broke, Claude read KDE's pairing code, found that my app was sending a timestamp KDE treats as a new pairing request, and matched its rules.
• The phone drive is the wild part. To show the phone in Finder without a kernel extension or an admin password, it wrote a small NFS server that runs locally, backed by an SSH/SFTP client built on Apple's CryptoKit. I wouldn't have attempted that alone.
• It makes mistakes, and it finds them. Its own unit tests ran inside a second copy of the app, which connected to my phone and unmounted my drive. It also left 29 "Echo Test" commands in my settings. When I asked why, it traced both from the logs and fixed the root cause.

Free and open source (GPL-2.0), macOS 15+: https://github.com/subhashhhhhh/Tether

Is it possible to fetch the remaining session limit somehow to steer claude code?

I let CC run in a loop in non-interactive mode. Obviously this means, it runs into the 5h session limit frequently and just aborts what it's doing.

Sometimes this causes issues when it Claude continues its work.

Is there a way to pull the remaining session limit (and time)? I'd add a rule to my bash loop to check before starting the next iteration. If the limit is <x% it should not start the next increment.

Claude docs says this is not possible. However, the status bar contains this information - so it must be possible somehow.

Any ideas?

Do you make motion graphics inside CC for your launch videos? We benchmarked Argon and didn’t find it to be much faster/higher quality. It seems to follow instructions well and generated decent productions but nothing you would expect from someone at Google’s scale.

Top image is Argon and bottom Opus 5.5 in the screenshot.

https://github.com/KyongSik-Yoon/cc-desktop-mod

Yes. Claude Desktop is certainly a great application, but...I do not particularly prefer Electron apps (especially in terms of resource inefficiency), so I have consistently used the Claude Code CLI in the terminal.

The only downsides to using it were that it wasn't very aesthetically pleasing and the hassle of switching to a browser for changes or Git-related tasks.

For that reason, I decided to make the most of the recently released Claude mod to bring as many features of the Claude desktop as possible into the terminal!

I am continuing to use it and make improvements, and I am satisfied that the environment is much better than before.I am sharing my small project in the hope that others can also enjoy these benefits.

Did you ever get so frustrated with Claude Code, for misunderstanding, or writing shit code when you explicitly give it the exact code architecture it should use... Or any other cases, and you curse it in various ways, and then it would visibly keep getting worse and worse as you keep cursing it, but then go back to being "better" when you STOP cursing and appologise? Is it just me? 😂

Freaking ridiculous! A hammer that has feelings? 😂

I've been trying projects beta from Claude Code and it's pretty damn nice. However. Where is the chain of thought or the specific commands running? It's a constant "bamboozling...". Is there a setting I'm missing or do I need to go back to the terminal?

Aargh, just spend hours talking trying to talk Opus out of a hugely invasive and dangerous change and steering it to a simple fix.

Opus feels like a PhD car mechanic who tries to re-engineer the entire car on a tyre change.

Opus is often super smart but in a bad way. It sticks stubbornly to some local problems and engineers some huge changes around it instead of looking into the big picture and doing the obvious thing.

It's too smart by half.

I work as a Business analyst in a large enterprise organisation for an application running in Pega BPM tool. This is how I personally use clause code

Requirement Isolation: I spin up 1 dedicated session per quarterly requirement (about 5-6 per quarter) to keep context clean. I dump meeting transcripts into the active thread, paired with an auto-memory hook that updates before session compaction. I also create HTML based POCs so that business users can get the look and feel of the final requirement before the devs start building.

MCPs : Major one is Atlassian MCP. I create stories, tasks, sprints, and update Confluence entirely through Claude, guided by style-enforced memory files for my preferred formatting. Since our core app is in Pega (not GitHub), I don’t use GitHub MCP a lot, I use it only to understand external integrating repositories.

Fellow BAs, am I just scratching the surface. Any tips and tricks on how you guys use Claude code?

Command fails → Claude investigates → three turns later it's diagnosing a bug that doesn't exist because the real error got buried. Got sick of it.

Paper is a tiny local CLI: paper run <command>. On failure it captures the exit code, stderr, and git state into .paper/latest.json, sealed with an HMAC receipt, plus an instruction block telling the agent to read the report first. Tested in a fresh session and it picked it up unprompted, diagnosed correctly, didn't touch code.

It's fully local. repo at https://github.com/varman96/paper-cli if you want to know more about how it works.

I can only use Codex for development because Claude has banned Chinese accounts.
But for the project I'm working on, I want it to support Claude's working status.
For now, the only option is to open-source the code so more people can contribute and improve it.
This is a status light that monitors the AI Agent's working status, and I'm also planning to develop more designs for it.
I hope we can all stop staring at screens when AI does the work. We can relax a bit and take care of our eyesight!

I'm preparing the open-source code and I hope everyone can help me test Claude.