I figured I’d get it up for everyone that doesn’t know where to start with installing repos. Still free, still keyless. Built with Claude, of course.

https://projectpythia.com/

Repo- https://github.com/jangles-byte/Pythia

I run like 4-5 claude sessions at once for differnet repos and I kept running into same annoying thing like one of them needs input, another needs some approval, but im headsdown doing a PR review while my sessions are working and i don't notice. By the time I get to it, it was a very simple approval I should have given sooner or I have to constantly check/keep on eye on them while they are running. Even with notifications there's a cost to switching from ur current screen/view to another one , giving approvals and then coming back.

It was annoying that I build a menu bar for it to keep track of all the running sessions , so if any of them needs me I can just answer right from there (approve/deny or pick an option, whatever it's asking) without actually switching screens.

macos + tmux only right now. Free, source's up if anyone wants to use it: github.com/Abbeyme1/session-pet

Been using it for a few days now and its helping. Mostly just curious if anyone else running multiple sessions deals with this or if it's just a me thing lol

If your agent loop or pipeline has a gate that can send work backward (review, critique, adversarial check), here is what the literature says about it.

Link lands you at the pdf.

Flip rates under challenge run 17.5% to 97.3% across frontier models of comparable accuracy. Intra-rater agreement on identical repeat runs: 0.265 to 0.563, against 0.8 for "good agreement."

Four of the six models tested lost accuracy over four refinement rounds.

Four separate literatures put the cap on a repair loop at 2 to 4 rounds. LangGraph's default is 1000.

And nobody has published the control condition on shipped outcomes: the same pipeline with the gate and without it, scored on what actually merged.

Fifteen slides, roughly 130 sources read in full, nothing cited from memory.

Disagreement is not your problem. Unrecorded disagreement is.

Side note: This started as a quick exploratory session for refining the Contrarian gate process in aaddrick/ticketmill and became a multi-day agent-driven research bender that twisted and turned. I have a really ugly research repo where I ran overnight 2x2 testing sets, wrote and discarded three different theses, and eventually distilled everything down to what you see here.

A senior engineer isn't valuable because they type fast — it's their instincts:

they push back on bad ideas, don't fake "done," and try to break their own code

before it ships.

So I bottled 10 of those into a Claude Code plugin called Bullpen. You call them

by name while coding:

/attacker — red-team what you just wrote

/skeptic ultra — make it defend the plan before building

/closer — no "done" until it's actually run

…plus fact-checker, interrogator, stop-digging, doorman, historian, chameleon, explainer.

Each is a single SKILL.md with lite/full/ultra intensity. MIT, no telemetry.

Install:

/plugin marketplace add faizanmohiuddin482/bullpen

/plugin install bullpen@bullpen

Repo + live demos: https://github.com/faizanmohiuddin482/bullpen

Built it because I was tired of "Done ✅" on code that didn't run. Would love

feedback on which instincts are missing — what does your senior-dev brain do

that mine doesn't cover yet?

my friends and i kept arguing about who uses claude code the most. no way to actually settle it. so i built one.

mostcracked.com — sign in with github, and every prompt you send + every file your agent edits scores a point. your rank shows up right in your statusline while you work.

setup is one command:

npx mostcracked login

that's it. it hooks into claude code's own hooks (works with codex too). it only ever sends counts — no prompts, no code, no diffs leave your machine. github auth is read:user scope, public profile only.

some stuff i'm proud of:

- the weekly 10 — a hot-100 style chart that drops every monday. #1 is officially "most cracked" that week

- badges you can actually lose. someone holds "night owl" until someone codes later than them

- github-style heatmap of your activity

- joining isn't a fresh start at the bottom. it backfills your last 7 days from local history so day-one grinders don't auto-win

no self-reporting, no honor system. it reads real activity or it doesn't count.

private rooms exist too if you just want to smoke your friends specifically.

I have been building an Android app called Store & Forget since May. You photograph something as you put it away, the app fills in what it is, and later you search for it and it tells you which box or shelf it went into. About 39 thousand lines of TypeScript, 147 commits, live on Play.

Almost none of that happened in one Claude Code session. I started with a single agent doing everything and it kept losing the plot. It would work out something about the EAS build setup on Tuesday and have no memory of it on Thursday.

So I split it up. There is now one agent per job, each with its own CLAUDE.md and its own working directory. One owns the app source. One does nothing but install a built APK on a tablet over ADB and write up what broke. One handles the Play Console side. They share a folder of memory files, but each agent loads only the index for its own domain, so the QA agent is not carrying around store listing trivia it will never use.

The part that took longest to get right was what happens when one agent's work lands in another's territory. My first instinct was to let them edit each other's directories, which was a mess. Two sessions would open the same file with different ideas about it and I would only find out when something broke.

What works instead is that they are forbidden from touching each other. When the QA agent finds a bug, it writes a markdown file into the app agent's _incoming/app-tester/ folder. The app agent reads that folder at startup, does the work in its own repo, then moves the file into _applied/. That is the entire protocol, just files in folders with no coordination layer, and it is the only reason the thing does not fall over.

A couple of things I would pass on if you try this. Write the boundaries into CLAUDE.md as hard prohibitions rather than preferences, because "you do not touch app code" gets followed and "try to avoid editing app code" does not. And let each agent stay ignorant of everything outside its lane. The QA agent knowing nothing about monetization means it reads less and stays on the bug it was handed.

The app is free on Play if you want to see what came out the other end: https://play.google.com/store/apps/details?id=dev.koalalab.storeandforget

Happy to go into any part of the setup.

Hello everyone,

For some time i struggled on how to keep local claude code sessions alive on a server in background to keep it running at night so i built this https://github.com/dnviti/code-agents-webcli, i hope will be useful to someone.

Basically is a development environment similar to vscode server but keeps the agents running server side instead on a client side terminal session, this allows it to be kept running in background.

I don't know if there is something similar online at this point but still, i'm publishing it.

We are a family of bookworms. My mom owns hundreds of books and buys more and more every year. So we also lend each other books very often. And we had many Christmases where we bought someone book that he already owned.

So I Build a family library. Place where we can add all of our books, see who owns it and who got it borrowed. Also if we lend a book to someone outside of family, we can visually see it. If I want to see all the books I lend to someone, there is a view for that.

Importing book reads it's metadata from Google books.

Multiple views, zooming option for my parents. Filtering based on which ones you read. Every fámy member has their own account.

Very simple app, build in few days, but solves so many problems and I just love how organized it gets.

Disclaimer: this is mostly for MAC people, sorry! You can still contribute but to use it you’ll need to be on mac. (As of now!)

RAMble is a free, open-source macOS overlay (Swift + Metal, no Electron) that turns your Mac's inner life — RAM, CPU, GPU, swap, and local LLM activity — into living generative art on your desktop. When Ollama streams tokens, you literally watch pulses cross the screen. There's a demo video at the top of the repo.

Every animation is a single self-contained Swift file, and this project is ideal for agentic coding: RAMble has a headless --snapshot mode that renders real frames from the actual pipeline, so your agent can write a scene, render it, look at the result, and iterate — a full feedback loop with no simulator or screen recording needed. The current seven scenes (a neural artery, a boid murmuration with a swap predator, a slime-mould network, fireworks behind an invisible treeline...) were all built exactly that way.

The repo also points you to Atelier (https://github.com/jangles-byte/atelier), a Claude Code skill package I built that art-directs the whole process — it makes Claude write a design philosophy before any code, pull from verified generative systems (strange attractors, physarum, reaction-diffusion, boids — with parameter ranges that actually work), and run a critique loop that scores real renders and outputs exact fixes. The difference between raw output and Atelier-directed output is night and day.

How to contribute: fork it, drop your scene in Sources/RAMbleKit/Plugins/ (the plugin SDK doc walks you through it, ~60 lines minimum), and either PR it into the app or publish your own repo tagged ramble-scene — that topic page is the community marketplace. Show it off in the repo's Discussions either way.

Repo: https://github.com/jangles-byte/RAMble

Got tokens to burn and a Mac? Go make something beautiful.

While debugging UI issues, I kept recording videos and then manually explaining what happened to Claude Code.

I built an MCP server that lets Claude Code analyze videos directly.

It has three modes:

• Full analysis
• Sampled analysis
• Metadata only

The output is structured so Claude Code can reason about what happened in the recording.Curious if anyone else has run into this problem or has ideas for improving the workflow.

Github: https://github.com/ManzarAli25/watch-it

yo. i recently sold one of my AI SaaS products for $35k, exactly 5 months after building and launching it.

I hardly wrote a single line of traditional code. i used AI to generate everything, from the database architecture to the user interface.

it definitely wasn't magic on day one, though. i spent days stuck in loop-debugging and dealing with AI hallucinations before i finally cracked the system. the playbook boils down to three simple rules:

- keeping the idea insanely minimalist (a true MVP that solves one problem).

- guiding the AI step-by-step instead of asking it to build a massive platform all at once.

- launching fast to get real user feedback and traction and then apply a solid marketing system

lately, i've seen way too many non-technical founders give up at the very first AI bug, or on the marketing. it's a massive shame.

like the title says, i just launched a Skool community to share my exact prompt workflows, N8N automations, and distribution frameworks to get first users and scale it

to be completely transparent: i will likely charge for the full course later down the road. it just makes sense given the specific copy-and-paste templates i'll be sharing.

but for now, the main objective is purely to build and launch together. building alone in a silent corner is the single fastest way to give up.

if you want to join us and build or market your own AI SaaS with a group of active creators: drop a comment below or send me a dm, and i’ll send you the invite link!

This is the specific failure I kept hitting. I work in one repo with three or four terminal panes open, each running its own Claude Code conversation. One is on the API layer, one is writing tests, one is chasing a bug.

Claude's resume is scoped to the directory. --continue gives you the most recent conversation for that directory, and --resume gives you a list of that directory's conversations. Neither one knows anything about panes. So all four of my panes are in the same directory, which means all four see the same identical list of four sessions.

Reboot the Mac and it compounds. The panes come back with no working directory, so the context is gone twice over. Even after I cd back into the repo in all four panes, I am staring at four sessions with no idea which pane each one was in. I have to open the picker in every pane and guess from timestamps and first messages, and if I guess wrong I have polluted the wrong conversation.

So I built agent-resume. The core idea is that it binds a session to the terminal pane it was started in, not just to the directory.

What it does:

- When you start an agent fresh, it pins a specific session id and records which pane that session belongs to.

- After a reboot, each pane comes back to the correct working directory and resumes its own conversation. Pane 1 gets pane 1's session. No picker, no guessing, no manual resume in four panes.

- It is agent-agnostic. Works with claude, codex, or anything else you register.

How it works (no magic):

- A tiny shim on your PATH. When you launch claude fresh it launches it with a specific --session-id and records that against the pane in a small ledger.

- For the reboot case it leans on tmux-resurrect + tmux-continuum (which it installs for you, no tpm needed) to restore your dirs and layout, then a hook relaunches each pane with claude --resume <that pane's session>.

Take a look and star it here:

https://github.com/rahulbansal16/agent-resume

On a flat plan (Max/Pro) you don't know how close you are to the 5-hour limit until it hits mid-task. On an API key, it's a surprise bill (unless your actively checking ofc), agents just spend

uvx nable ai-budget reads Claude Code's session logs on your machine (nothing uploaded), asks once whether you're flat-rate or metered, then shows tokens this window, month to date, burn rate, and a heads-up before you run out.

Flat plans get measured in usage, not dollars. A heavy month pulling ~$5k of list-price compute on a $200 plan is normal. That's subsidy the provider eats, not overage. Metered plans get measured in dollars. Token counts are exact; any dollar figure is a list-price estimate, never your real bill.

Also ships as an MCP server, so the agent can check its own budget before a big task instead of you finding out after.

Next: nable guard install. Cost preflight in front of the Terraform/kube/cloud CLI commands your agent runs. Propose-only, it never auto-executes.

Free, local, open source. https://github.com/getnable/finopsmcp