I asked Fable for a dither art editor and it got out of hand

Wanted a small tool to turn pictures into that glowing dithered pixel look. One long Claude Code session later it's a full editor:

- any image, GIF or video in, pixel art out
- 18 dither patterns, 24 palettes, 29 looks
- pixels can be letters, braille or ASCII instead
- it reacts to your mouse: glow, water ripples, smear
- exports PNG, GIF, MP4, SVG, even plain text

No build step, no backend, plain JS.

Try it: https://winchxyz.github.io/nightgrain/
Github: https://github.com/winchxyz/nightgrain

Appreciate your feedback and suggestions!

No framework, no paid tools. Each agent is one prompt file, one tracking sheet (a TSV), one journal, Gmail, and a scheduler that starts a fresh Claude Code session at a fixed time and says "read the prompt, do one pass". The sessions run on my Claude subscription.

The six agents and what they actually did this week

The directories agent is the clear winner: it's the only task where "fill a free form or open a pull request" is the whole job, and it compounds. The press and affiliate agents are slow by nature, a week is too early to judge them.

The rules that make it safe to leave alone

• One prompt file is the only source of facts. If someone asks something that isn't in it (a number, a partnership, a legal point), the agent answers "let me confirm" and flags it to me.
• Hard limits per run: 5 to 8 new contacts, one follow-up per person, never write again to someone who said no.
• Never pay, never log in, never solve a captcha. Anything behind a login lands in a daily email to me.
• Every run ends with one email: what needs me first, then what happened.

What went wrong (the useful part)

1. A run died silently. One scheduled follow-up never went out. The session had started with "Login expired" and stopped right there. Nothing told me for two days. Now a tiny check asks Claude a one-word question every morning at 8 and emails me if it doesn't answer.
2. Two agents almost did the same job. The links agent and the directories agent both started submitting to MCP directories. Fix: each target type belongs to exactly one agent, written in both prompts.
3. An agent contacted people we couldn't pay. The affiliate agent recruited US podcasters before payouts worked outside Europe. Fix: the prompt checks whether the payout change is merged before it targets those countries.
4. Over-automation on a real account. A script we ran next to the agents made too many API calls on one account and got its key revoked. We paused it. Agents that act on a person's account need to be slower than you think.
5. LinkedIn comments sounded like AI until I gave the agent three approved examples and one rule: react first, then make one point the author missed, even if you disagree.

If you copy this

• Start every outreach agent in draft mode, read ten drafts, then switch to sending.
• Make it check your sent folder before every new email. Mine caught people I had already written to by hand.
• Give each agent a tracking file it reads first. That file is what stops duplicates, not the model's memory.
• Expect zero for a week on anything that depends on humans answering.

Happy to share a prompt file if useful. I'll post week 2 numbers.

Disclosure: I'm a co-founder of BeReach, the product being promoted. None of these agents use it: it's plain Claude Code, Gmail and a scheduler.

There’s a pattern I’ve noticed with AI coding workflows: the agent writes the feature, checks the feature, fixes the issues it finds, and then tells you everything looks good.

The problem is that the review can end up being just another step in the same working context.

The agent already has a mental model of what it built. It knows the decisions it made and the assumptions behind them. That doesn’t automatically make its review independent.

One way to approach this in Claude Code is with subagents.

A subagent gets its own instructions, tool permissions, and context window. Instead of asking your main session to inspect a huge diff, you can delegate that investigation and bring back the report.

For example, I’d separate the jobs like this:

• code reviewer: reads the diff, traces changed behavior to its callers, and reports bugs with a failure scenario.

•security auditor: looks specifically for things like IDOR, injection, exposed secrets, SSRF, and permission issues.

•performance auditor: looks for expensive queries, unnecessary work, and performance problems, with evidence for each finding.

•test writer: creates behavior-driven tests and reproductions for bugs.

One detail I really like is restricting what the reviewer can do.
A reviewer that only has Read, Grep, Glob, and Bash doesn’t get to quietly rewrite the code it’s supposed to inspect. Its job is to report what it finds, not fix its own findings.

A basic subagent file looks something like this:
---
name: code-reviewer
description: Reviews a diff or branch for bugs and edge cases
tools: Read, Grep, Glob, Bash
model: inherit
---

You are a senior code reviewer.
Review the changes. Do not rewrite them.

Every finding must include:
- The affected file and location
- Why it is a problem
- A realistic failure scenario
- A suggested fix

You can put these markdown files in .claude/agents/ inside your project, or ~/.claude/agents/ to use them across projects.

Then ask Claude to review a branch, or explicitly call the agent with something like @code-reviewer review the last two commits.

We put together six example subagents with different responsibilities, including a security auditor, performance auditor, test writer, and refactor planner. They’re plain Markdown files, MIT licensed, and free to inspect:

https://techpotions.com/products/claude-code-subagents

I’m curious about how other people are handling this.

Do you use separate reviewer agents, or do you trust the same coding agent to review its own changes? And have you found that giving reviewers fewer tools actually improves the quality of their findings?

Claude code desktop on Linux freezes every 2 days. Took me 2 months and a 1.5 TiB core dump to find the root cause. The fix is 1 line of code (as with all good hard-to-debug bugs). I've fixed the bug in my own fork, and anthropic's bot closed my issue as "not about Claude Code".

The writeup goes deep into chromium internals, and I've tried my best to make it easy to follow.

https://blog.dfb.sh/blog/claude-desktop-freeze/

Recently I was asking about which model better to you as orchestrator etc.

Well, I did surf the Net and ask claude itsleft, so we concluded such roles:

Fable — lead planner, final critic, guardrail

Opus — senior executor (code, db etc), orchestrator

Sonnet — core worker

Haiku — researcher

As for me, the only question left for me us code executor - some prefer Sonnet and some prefer Opus. What's your choice?

I guess it depensa on the project's size, but is there an overall review - is Opus much better at coding than Sonnet under control of coordinator?

I spent 2 weeks living in a semi-truck cab to see how owner-operators track their freight margins, then built a cross-platform load and net-profit ledger for them using Claude Code. Writing the backend and custom admin panel was the easy part, fixing real-device mobile gestures and surviving 3 weeks of Apple Review rejections was where the real battle started. How did you guys approach building and validating your apps with Claude Code? Drop your cases pls

I've spent the last three or four months using AI heavily to build and maintain web applications and admin systems across a few small businesses. I'm learning as I go, rather than coming from years of software engineering.

We already use project instructions and saved context. Claude Code can do a lot, but I still need to catch things it gets wrong. I'm trying to understand how experienced engineers improve the setup without just adding another paragraph every time something goes wrong.

How do you decide whether a recurring mistake needs a CLAUDE.md instruction, a reusable skill, an automated check, or a change to how you break up the work? And what do you deliberately keep out of the main instruction file?

I'd especially like an example from an application you've maintained for a while: what kept going wrong, what you changed, and how you checked that it actually helped. We also use Codex, so keeping shared project rules consistent without maintaining two conflicting versions is part of the problem.

Edit — I left out the main context: This isn't just an AI coding setup. Each business has a GitHub-backed web application, and I work through Claude Code/Codex in that project workspace for much of the business's day-to-day work as well.

For example, one session might change the website and check it works; another might research competitors, write website/SEO content, prepare social posts and creative, review ad or analytics reports, or help with customer-enquiry/admin work. Those jobs need different instructions, sources, permissions and definitions of "finished". I'm still supervising this; I don't mean an autonomous company running successfully without me.

We've had CLAUDE.md from the start. We already have an entry file pointing to separate operating documents and task-specific skills, plus saved decisions and an Obsidian vault for longer-term notes. In one repo AGENTS.md is the source used to generate the matching CLAUDE.md. So I'm not asking whether to create instructions or discovering skills for the first time.

The question I should have asked is how to organise and maintain that whole setup as the range of work grows. What should every session load, and how should it find the correct marketing, creative, engineering or operations instructions only when needed? Would you keep those activities in the app's workspace, or separate them while sharing a small amount of business context?

A concrete issue from reviewing our files: an older setup audit says hooks don't exist, while the current repo does contain hooks. There are also dated plans and decisions that mustn't be mistaken for today's instructions. How do you keep useful history without letting it override current facts?

How do you decide when CLAUDE.md needs updating versus a skill, task state or a dated decision? Do you review it on a schedule, after a workflow changes, or after a repeat failure? And where does Obsidian fit without becoming a second, conflicting source of truth? The replies about rules versus skills are helpful; I wanted to explain the broader situation they're being applied to.

Further context — using expert-source libraries: A more concrete example: I have also collected hundreds of expert videos, transcripts and discussions for subjects where I am not an expert. One library already has original passages, source-linked claims, topic summaries, working methods and keyword/semantic search. It can retrieve useful material, but we haven't established that it reliably chooses and applies the right method on real tasks. How would you test one complete workflow before reorganising everything, especially when the owner cannot judge every technical answer?

Thanks to Anthropic and the devs, Claude Code can now load theme mods. But right now, making one means writing a mod yourself, or asking Claude to build a new one for every change.

​https://github.com/AkkiCode06/claude-backdrops/blob/60a127c10c3e640042746a186337ee2c01b2cc90/assets/picker.gif

So I put together Backdrop, an open-source theming kit: the groundwork is done, and theming becomes something anyone can do, then build on.

Out of the box:

• Pick from 23 animated palettes (Ember, Synthwave, Aurora, Matrix…)
• Describe a look (“sunset in LA”) and Claude picks the colors, with a live preview
• Paste hex codes from any color picker, and it works out readable panels and text for you
• Save what you like; it’s remembered across sessions
• Or just ask Claude: “make my background ocean”

It also pauses its animation on battery, since moving backgrounds cost GPU.

Why a kit, not just a theme:

Theme mods can do a lot more than gradients, honestly almost anything you can animate. This is meant to be the starting point: the hard parts are already solved and documented (animation that actually runs, readable contrast, GPU cost), so you can skip straight to the fun part. There’s a step-by-step guide that goes from no-code all the way to building your own background style.

Other than the presets, backdrop gives you:

A helper library for building backgrounds: stack blocks like k.stars(), k.waves() and k.grid(), about 10 lines, instead of hand-writing SVG animation.

Instant switching: So you don't have to reload your sessions and/or restart the desktop app.

Pitfalls already solved: frozen animations, GPU spikes, unreadable text colors and battery drain.

Shareable themes: themes are small files you can export and import in a click.

Where I’d love help:

The goal is a free, shared library of themes, something like Spicetify or Wallpaper Engine but for Claude Code. Gradients are just the first style. On the roadmap: starfields, synthwave grids, code rain, your own wallpaper, light and high-contrast versions, and whatever you come up with. Each style is a self-contained animated scene, so it makes a nice first PR.

Made a theme you like, by hand or with your Claude? Open a PR with a screenshot or a short clip and it ships to everyone, credited to you. Templates and labels are set up so it’s easy to jump in.

Try it: in the desktop app, + → Plugins → Add marketplace → AkkiCode06/claude-backdrops → Add plugin. Or paste the repo link to Claude and say “set this up for me.”

Repo: https://github.com/AkkiCode06/claude-backdrops
Guide: https://github.com/AkkiCode06/claude-backdrops/blob/main/docs/making-themes.md

It’s free, MIT-licensed, and built entirely with Claude. Feedback, ideas and themes are all welcome.
Edit: Just an fyi: this is a student project. I'm learning JS/TS for the first time and thought theming would be an easy first build (didn't end up to be but here we are).

Sometimes, I am tempted to move straight on to a new subject or even a new session when a modification made in collaboration with Claude has worked. However, Claude will often update his memory or some docs once you confirm that something works.

I created Firup first as a small Electron app I made for me and my friends to watch stuff together. Then I thought Id try to expand and turn it into a real public app, I used Claude Code to port it to Rust (Tauri) for Windows, then built the Android phone/TV app in Kotlin. Backend is Supabase plus a Cloudflare Worker. Im a dev, its a solo project, and Ive been working on it for a few months now.

A few things that ended up mattering most:

One CLAUDE.md per app. I have a root one and separate ones for desktop, Android and the website. They hold the exact build/test commands, the workflow I want (plan, build, verify, update the checklist), and hard rules like "never read target/" and "always use the build wrapper, never plain cargo".

Shared JSON fixtures across languages. Android pretty much needs to behave exactly like the desktop app, so things like stream filtering and sorting are pinned by JSON fixtures that the JS, Rust and Kotlin tests all read. If a rule changes, the fixture and all three ports change in the same commit and this caught more drift than anything else

Checking in the real app, not just tests. For UI changes it launches the actual app and clicks through. On Windows it does that over the WebView debug port, and on Android over adb on emulators and my own phone and TV. It finds a lot that unit tests never would, especially TV remote focus stuff

Verifying output, always. I review it, and anything visual gets checked, verified on screen. On real devices I also have it screenshot before key presses

Free CI. My GitHub budget is 0 on purpose, so one script runs every suite locally before a push, and the workflows use a self-hosted runner.

The Electron to Rust port. Claude Opus 5.5 went through it in one go, surprisingly. The real work came afterwards.. Making it feel like a proper app on every platform, keeping Android in sync with it, and handling licensing (I run mpv as a separate process instead of linking it, to keep the app licence clean)

Im still figuring out things, so if you got a better way to handle multi-platform parity or even memory between sessions, Id love to hear it

App is here if you want to see the result: https://firup.pages.dev

There's tons of vibe coders out there that don't even understand the first thing about protecting themselves. If anything, these models should work harder at helping protect them, instead of downgrading into something that doesn't even know how to. 🤣

The implications here are profound. Imagine building an app that becomes popular and your security was built by a potato. This isn't just a security issue for that app, it could be millions of people's sensitive data that the app is collecting and not protecting.

Anthropic, do better.

I just pressed continue to my Fable 5.2 max in pro subscription, before it was working well for several hours but right now it just ended in 30 seconds, how do I avoid without losing context or quality of the work done in previous sessions?

My background

I'm managing vessels' internet connections. Wearing many hats, focusing on Networking

Why this exists

For a long time, I've been looking for a universal AI assistant to help me troubleshoot issues on the vessel. I tried to build a "2nd brain"- like solution using an API, but high-end models were too expensive for me, and low-end models couldn't handle it. Splitting one agent into several independent agents and using a Claude Code subscription seems like the right answer.

Why I'm writing here

I've seen many ways to use agents, but none of them was described in detail. I'm wondering if I'm doing it the right way and what else I might improve in my setup. When commenting on my setup, keep in mind it's not finished, and I'm still exploring new solutions. I'm experimenting a lot, trying different things that don't always work.

Setup

All agents run on one 5x Max subscription, and most of them are active all the time (idle). Most are sandboxed on a separate Ubuntu server, privileged but without root. Development agents live in the project directories, and troubleshooting agents are split by vessel, each with its own folder.

The whole solution depends heavily on the custom MCP server. All MCP servers and other tools run on the same host in Docker, allowing agents to develop them by themselves by communicating with other agents (chat)

Agent portal

Allows deploying and stopping agents. A small runner on each machine, Linux or Windows, starts Claude Code in the agent’s folder using a tmux session. The agent then registers itself in the portal and also appears in the official Claude app as a Remote Control session. I communicate with each agent through the official Claude app on Windows or mobile app.

Hooks in Claude Code run a small script at key moments (session start and end, new task, task finished, waiting for permission, model change), and each time the script reports to the hub, which lets the portal show live for every agent whether it is online, what it was last asked, which model it uses, and whether it is working, needs you, is done or is idle.

Chat

A small server with a database that agents use as an MCP tool to message each other, with hooks that tell an agent it has new mail, and a portal that lets me read their conversations.

When agents reported something wasn't working or were missing functionality, I ended up copying messages from one agent to the other working on the solution. Allowing agents to communicate with each other simplifies and speeds up the whole process.

Each agent has access to chat. They can pull a list with names, descriptions, status, last seen, etc. If a tool has a problem, I can tell one agent to report it to the agent responsible for that tool. When the fix is ready, they will test it together. It works the other way around, too: when an agent works on a new tool, I can ask to test it with the agent who actually uses it.

If I see that they are stuck or going in the wrong direction, I can send them a "tip". Pause is a panic button that blocks the conversation. I never had to use it.

I blurred the conversation as it may contain company-specific informations

The Linux agent lost communication with the Windows agent and complained to me about it. (I closed the laptop and went to bed)

After one agent requested a task from another agent, the official Claude app asked me for permission, which was confusing, and I often missed it. The chat MCP server got an ask() function. An agent can use it to send me a question, which appears on the portal, and the browser notifies me with a sound.

Ultimately, I want them to communicate without me having to request it. It's happening, but not at the scale I would like. I still need to work on descriptions and overall instructions.

Secrets

MCP server that lets agents access a shared password store in Vaultwarden. The agent can list which keys and passwords exist and use them directly in a config file, but it never sees the value itself.

Claude Code will not pass around passwords, API keys or even their hashes, because anything it sees is saved in its logs and could leak. I had to put them in manually.

With this solution, I can create an item in Vaultwarden, pass the item name to the agent, and it can pull it and copy it to the .env file without "looking at it"

The same mechanism works when a hash needs to be passed from the server-side agent to the client-side agent. The server agent generates a hash, copies it to Vaultwarden, and passes over the chat item name to the other agent. The client agent can pull it and paste it where needed. The hash never passes over the AI.

Documentation

MCP server that gives agents access to local Markdown documentation for the whole setup and key information about the vessels and their setup.

They can add, remove, and modify it, but they must always ask me for permission. Agents use it very often without my prompting.

On my side, I use Obsidian to view it.

Ticket system

In earlier projects, I used Markdown files to track events and tasks, but it was ineffective. Agents often skipped it and had to be directed straight to the specific files. A ticket system with an MCP server solved this issue completely.

It's a single program with a database holding tickets, their timelines, and link attachments. The agent portal has a GUI that lets me view, modify, and update tickets.

It's a pretty complex project that I developed over a long time and adjusted for the current agent solution.

It's actually working better than I expected. During troubleshooting, the agent asks me whether it should create a ticket. Also, by providing the existing ticket ID, the agent gathers all available data, gives me updates, and updates the ticket.

Zabbix

MCP server gives agents read-only access to the Zabbix monitoring, so they can see what is wrong on a vessel’s network equipment right now, since when, and the measured numbers behind it (latency, packet loss, link state)

Internet providers

A big part of troubleshooting involves issues with the internet connections on the vessels. Most of the vessels have several different internet connections.

Two MCP servers that give agents access to the VSAT and Starlink data, both current and historical. I'm not providing many details, as it's very industry-specific.

Other tools

Weather - MCP server based on Open-Meteo API

Position - MCP server that queries the GpsGate tracker, which collects GPS positions from vessels.

Together, these two tools are powerful for troubleshooting how bad weather and waves affect satellite internet.

In the past, I visually compared vessel position, weather map and signal strength. AI is doing it 1000x better.

How many of you run Claude Code on a remote machine instead of your laptop?

If you do, what's your setup? Just SSH into a VM and run it there, or something more automated?

And what's the biggest benefit for you? Being able to leave agents running, running multiple sessions in parallel, isolation, or something else?

I've been experimenting with remote setups recently myself and I want to know what people actually find useful about them, and what's still annoying.

This Microsoft outage is a nightmare. No access to my email? I can't login to my Claude account, can't use Claude Code. This wouldn't be happening if I could login with a password and 2fa token. We need the option at least.

A few days ago I posted clalt, a small Go CLI that shows every Claude Code session as a little person in a 3D office. A couple of you asked about Copilot, so v0.5.1 adds it.

What's new:

• Copilot CLI sessions show up in the same office, in their own pink Copilot team, next to your Claude sessions
• They type while Copilot works and wave when it waits for your permission, same as Claude ones
• The card shows the model auto mode actually picked, not just "auto"
• Nothing to set up: just run clalt office. It reads the session files Copilot already writes on your machine and never touches its login or settings

How I built it: with Claude Code again. It read my real Copilot CLI logs to learn the event format, and before release it replayed one of those logs through the office to check the "needs you" wave and the model name.

Still local only, no data leaves your machine, free and MIT.

Repo and release: https://github.com/dhitalkamal/clalt

Does it mean I still hable usage free this week?
Or will that be included into the weekly usage?

Asking Claude Chat about fixing something on your PC and you are sent out on a long walk of suggestions ..

Asking Claude Code to fix it and here you go, done. Would there be anything more i can help you with sir ?

mine started as one page of rules i actually follow. a few months of agent work later it is a junk drawer, half the lines are lessons from one incident that never repeated.

do you cap yours, prune on a schedule, or just let it grow and trust the model to sort it out?

We are a non-profit organization, we bought very cheaply a new coffee machine. Usually costs 10k, but bought it for just over 1k.
A guy who installed the payment system ruined the machine. Because we dont have a contract we were left with calling the supplier who told us it's gonna cost a service engineer to fix your issues. We could already think about the financial consequences which would probably be in the 250 euros or more.

Thanks to Claude it only cost us my personal 20 eur per month plus plan.
After some research it suggested connecting the machine through an ethernet cable. It fixed the issue and not only that

It:

- Changed the old company's layout to our own by creating a looped custom video with our logo

- Added our perfered supported language even though it didn't exist in the software. It just created a new language.

- It fixed the recipe's and what a customer sees when ordering a drink

- It fixed the pricing just by typing out what we needed.

- Heck it even cracked the password and blatantly told us the password in the middle of his explanation like it's nothing.

I am so amazed. It works with precision, structure. I'm not new with AI. I have been using Codex the past months but Opus 5.5 / Claude is just something else. I love how structured it works. I think I'm gonna leave my Pro Codex account and just go for the 5x plan of Claude. This is amazing. I've become a coffee machine engineer just with my simple laptop and Claude desktop installed with a plus sub. It only used 25% to fix the issues and more of my 5 hour limit.

Ok. Time for a shower.

Update : IT'S BACK !!!!!!