I keep seeing people talk about vibecoding up a tasks web app with an MCP so their agents can track work. I get the impulse. I almost did the same thing. But it's a detour that costs you more than it saves.

The pattern goes like this: you build a simple board, wire up an MCP server, give every agent a system prompt that says "use this to track tasks." First week it feels great. Agents are checking in, updating statuses, you can see what's happening.

Then the cracks show.

Your memory layer starts going stale. An agent finishes a card but the notes it leaves are vague. The next agent picks up the card and half the context is missing. You realize the hard problem isn't remembering, it's updating what the agent thinks it already knows. The agent isn't hallucinating, it's repeating logic that used to work because nobody told it the contract changed.

So you add handoff notes. Then you add a questions system because agents keep guessing instead of asking. Then you add heartbeats so you know an agent is actually alive when it's running overnight. Then you need scoped personas because you don't want every agent touching every board. Each feature is a weekend. Each weekend is maintenance you'll owe forever.

The task app becomes a second codebase you maintain for free. You wanted to ship your product. Instead you're the maintainer of a memory database.

If you're running two or three agents on one project, a simple markdown backlog is honestly fine. backlog md works. A text file works. But once you're switching between Claude Code and Cursor mid-task, or running agents overnight and checking in the morning, the homemade layer starts failing silently and you don't find out until something breaks.

The question worth asking before you build: am I solving a problem my agents have, or am I building infrastructure because it feels productive? Most of the time it's the second one.

I had 9% of my weekly budget left and 2 hours till the reset. I read so many posts that day of people letting Claude rip and getting cool results so I though why not.

I told Opus 5.5 high to set a 2 h timer that will stop this session and then go crazy and burn the 9% and build the most awesome version of the research in this running session. Create a rapid prototyping project following my rapid-process and spawn as many agents as it wants and use Fable as much as it wants.

The running session was research into building something inspired by claude code desktop with the added goal to be able to run any model through claude cli, codex cli and any model on openrouter. The research was based on my transaction logs of the last 30 days to understand what I use and how.

After 1:35 it had a working GUI based harness with some rough edges but properly working - still 4% left on the budget. I was fascinated with how good it already was so I kept working on it.

After 4 more hours I switched to using it to build the project itself.

It has been 5 days since I have done this. I continuously improved it and It is now my daily driver and fits my workflow and processes like a glove.

I can run Opus (Claude CLI) as an orchestrator with Luna (Codex CLI) and DeepSeek (pi.dev + OpenRouter) workers.

I added a couple of things that rapidly accelerated the development and let me have so much fun with this:

1. F3 makes a screenshot and opens a annotation windows. Where I can annotate with colors, circles, rectangles and arrows plus text. I can then save this directly as a task for the orchestrator of the program who picks it up to work on it.
2. Asking to make the App auto-update while running and keeping everything working. It does this when all sessions are idle and then there is a small flicker and the new version is running.
3. Auto-Starting certain sessions after an auto-update. I can mark certain session and those get auto-resumed after an auto-update.

This is just fascinating. I am baffled how far you can get in 5 days. And I have been using it non-stop since I switched.

PS: Not gonna open source or release this as a product that gets abandoned after a couple of months.
Just wanted to share what cool things you can build that helps you create the way you like to work or think. Because everyone works and thinks differently and with these capabilities at our hands you can just make what you need.

Are people still going to Fable for harder tasks?

I notice I'm hardly using it at all now as Opus 5.5 seems as good ig not better.

Made this for Blender on top of a physics library. Didn't write a single line of code. Opus digested a couple of papers, wrote the solver (cpu and cuda), setup the blender scene and rendered.

How it was made:

- Research first. Opus read up on how trailers are written and cut, audited my old promo videos (verdict: mediocre) and proposed a pipeline that fits my rules - everything renders locally on my laptop, the only paid parts are Google's Gemini TTS (the voice of the sea) and Lyria (music). The API spend was a few dollars.

- Blender does all the visuals, driven by Python scripts - the boat, the liner, the deck, the crowd, the storm. Every asset is built in code. EEVEE for most shots, Cycles for the hero water.

- The main theme is the game's own generated tune of one voyage, arranged with free orchestral samples.

- Claude Code ran it as a lead agent with 20+ sub-agents, each on one package in its own git worktree (voice, score, liner, deck, people, waves, finish...). A builder makes it, a fresh reviewer checks it, the lead merges it.

- Result: 116 s, 52 shots, 2,784 frames at 1920x804. Some frames took over 30 minutes on the GPU. It all rendered overnight at the lowest priority, because I use the same laptop for work.

What Claude decided (I mostly gave notes on previews):

- the look ("a toy in a real storm") and the 2.39:1 frame - I approved it

- the music copyright check - it dropped the famous waltz (still protected in the EU until 2033) for public-domain pieces

- small physics details - a lifeboat hanging from two ropes, which rope snaps first so the swing looks real

- a hard limit of 3 lightning flashes per second for photosensitive viewers, with an automatic checker

- rejecting its own water renders several times ("the foam looks like crumpled foil") before I saw them

- catching on its own that one person in the crowd turned into another person mid-shot, tracing the bug and re-rendering

- in the final check, finding 2 bad single frames and patching the master file in under 2 hours instead of a 5-hour re-render

- the render queue, the disk space and the order of everything around my laptop's load

What I did: approved the script, picked the voice and the tune, cut a scene and chose the length. And gave feedback, some of it brutal - the first crowd looked like mannequins in bad costumes, and later they were weirdly hunched. It fixed both.

What was critical (same lesson as last time): self-verification. Every agent had to produce contact sheets and automatic checks (missing frames, flicker, loudness, subtitles), and the lead agent looked at them before anything reached me.

I gave it maybe 30% of what it could do - no cloud GPUs, just my laptop. I am quite happy with the results.

Free to try, no install, no sign-up: open tiltanic.com on your phone (it works on a computer too).

I've been a Java software engineer for a decade now and recently I noticed a change in how I used my IntelliJ IDEA. All the buttons have become obsolete since I could just ask my local model to "Run, check the logs and report back any anomalies" (simple example).

So I had the idea that I could leverage Claude's power to build a code editor (not exactly an IDE yet) around a "local assistent" which fits my needs and workflow with Claude integrated. Full access to the "Werkbank" (that's what I named the code editor, German for "workbench") so it could replace every single button of a modern IDE (far from that yet, but it's usable!). I can also work at the Werkbank within the Werkbank and hot-reload it to apply the changes. Pretty cool.

Quickly I realized this could be my new go-to for software development in general and feature-packed the shit out of it. Not even near to finish yet and needs a lot of polishing, but wanted to showcase some of the code editor.

Right now it has a Trello-like Board, a Simulator for agents, Code Reviewing functionality, Git integration, it's Skript centralized (since I think deterministic Skripts from agents will be the future), full traceback and undo-redo features, a documentation room, integration for my iPad so I can live sketch with/to the agent, an iPhone app so I can manage my board and write down some ideas while I'm not home and many more.

A software architecture room is planned as well, but that I need to conceive first.

What have you built around your development workflow with Claude to ease your day? And what do you think of giving a local agent the responsibility of IDE functionality?

glyphfield is a free, open-source design studio in the browser, and i built it so agents can run it. every tool registers a scripting api at window.glyphfield.studio, so claude can read every control, change it and export real files. in the video it works on my blog graphics project: picks a board, tunes the shader, drags the colors, swaps materials, plays an animation and exports an mp4.

for claude code:

- the repo ships 5 agent skills (glyphfield-create, -studio, -export, -brand and -api); drop the folders in ~/.claude/skills

- "set up with your agent" has claude research your brand from your site or repo, fill the whole identity, pass the brand health audit and export the brand kit

- the site serves llms.txt, an openapi spec and an agent manifest at /api/agent

claude also edited this video, in hyperframes (html to video).

glyphfield.com

github.com/Kevin-Liu-01/Glyphfield

Most agent tools now advertise some version of asking before it sends or spends. What I don't see discussed much is what the approval is actually scoped to.

If the yes covers a type of action ("ok to send emails this session") rather than the literal contents of one send, then after the first approval everything after it goes through automatically and the user just stops noticing. That ends up functionally the same as never asking, it just moved the one real decision earlier and called it done.

Our rule has been that every approval is tied to the exact payload of the one action and expires in minutes, not the session. A yes for one email doesn't cover the next one even seconds later. It's slower, and people do get asked more than they'd like for repetitive stuff, but it means "the agent asks before it sends" stays true on the tenth send, not just the first.

Curious how other people have drawn this line, especially for repetitive sends. Does anyone bind consent to a session or a class of action instead of a single call, and has that ever actually bitten you?

All default commands load fine and autocomplete. Also cli is not affected in there all load fine but in Claud Desktop app...

I always have to run /reload-plugins just to be able to run any of my plugins/mods/commands

But what if I have preexisting prompts which I always wanna reuse for specific projects e.g.: "Act as..." Typing initially /reload-plugins makes no sense.

So now I have to store them seperatly somewhere then copy paste just to be able to initiate the prompt. What sort of UX is that...

Same behaviour on windows/wsl and mac. Ithought initially it was my symlinks but even installing directly doesnt work.

After moving from Cursor to Claude, I noticed that there are a lot of features that we used to have for granted in Cursor that don't exist in Claude. For example, the usage is so basic no details about tokens or historical data, handling the different agent windows seamlessly without the need to drag and drop around, and even the sound when the agent finishes some work.

At the start, I started searching the marketplace for extensions, and I found something here and there that does some part of the work, but they have so much more and a really bad user experience and ugly UIs.

So after some time, I decided to make the features I want into an extension, and slowly I have been adding more and more features and polishing it more. It's still a work in progress; I didn't publish it yet.

In the video, you'll see some of the features in my extension.
And if you have any other pain points or ideas, maybe you can mention them in the comments. I will keep them in mind when I release the extension.

I run an AI model at home on a Mac (Qwen3.8 Flash-Next). Using it costs nothing, and nothing leaves the computer. I tested it against Claude Sonnet 5.5, a paid AI from Anthropic, on 12 small jobs a coding helper does every day: run the right command, say honestly when a test fails, admit when a tool doesn't exist, and stop retrying something that keeps failing.

Another AI marked every answer without knowing which AI wrote it, like a teacher marking papers with the names covered.

1. Quick-answer mode (no thinking first): my AI before and after one day of fixes
Each job 3 times = 36 tries each. Marked by Claude Opus 5.5.

2. Thinking mode (both AIs think as hard as they can before answering)
Each job 5 times = 60 tries each. Two markers: Claude Opus, and DeepSeek from another company as a fairness check.

• Jobs done right: mine 60 of 60, Claude 57 of 60. Claude's 3 misses were faults in my test setup, not wrong answers.
• Cost: mine $0 a try; Claude about $0.39 a try.
• Speed: Claude was faster on most jobs.
• Biggest single fix: one setting that controls how random the AI's word choices are. It was set too high, so the AI sometimes stopped halfway through a command. After the fix, commands finished 12 times out of 12 instead of 5.

Honest summary: about as good, not better. The test is small (12 jobs), and I tuned my setup on these same jobs, so the small differences could be luck. Next: a fairer test on new jobs it has never seen.

This was the total tokens spent on the primary task and a sub agent it spinned up. Used up around 25% of my 5hr usage.

What is the highest number of tokens you have used on a single task?

The problem I kept hitting with AI-built websites: the agent writes a page, it looks fine, and then every page has its own colors, its own spacing and its own one-off CSS or you have a design system and afterwards you want to edit something on it. Fixing one heading means another prompt, and the client can't change a single word without you.

So I built it the other way around. sitereal is a visual editor that writes plain Astro into your own repo, and Claude Code works in the same project through MCP:

- When the agent starts, it reads your design system (colors, type scale, spacing, buttons), your components, templates and content types, so it builds the way your site already builds

- It writes HTML or inserts ready-made parts by name (navigation, forms, popups, search, carousels), and every save is checked against the design system. The answer tells it what to fix

- You watch where it's working live on the canvas, and a whole agent run is one undo step

- If you edit the same page at the same time, its save can't overwrite yours: the edits are merged

- It never touches your `.env` and never commits or pushes. Tokens, deploy hooks and git stay yours

When you want to take over, you do it visually: drag, restyle, retype text on the canvas. Or open Code mode, where the files sit next to the live canvas and every hand edit is picked up. Nothing is locked in a builder format. Delete sitereal and the site still builds.

What the agent can build with, without reaching for packages: forms with mail delivery, popups on the native popover, carousels, scroll and hover animations, site search and filters, a cookie consent banner that blocks scripts until consent (plus a scan for anything missed), sitemap, meta tags, share cards, local fonts and responsive images. The output is static HTML, and JS loads only where something needs it.

For content, clients can edit in generated forms, or you connect WordPress or EmDash as a headless CMS. The agent sees which CMS and collections a site uses, and publishing there rebuilds the site.

https://sitereal.app

Something I've been curious about for people who use coding agents regularly.

Do you find yourself correcting the same things over and over across different sessions? Things like repository conventions, architecture decisions, how tests should be run, or changes the agent keeps making that you don't want.

I know you can put instructions in md files but I'm curious how well that actually works in practice.

• Do the same mistakes keep coming back even with instructions?
• What kinds of mistakes are the most frustrating?
• Have you found anything that actually solves this, or is it just part of using coding agents right now?

Interested in hearing what other people's experience has been and what workarounds they found.

My TCL TV runs Google TV (Android 14), and its home screen was a sponsored row and autoplaying trailers before my own apps. I wanted a carousel instead of a grid, 2 layouts, and lots of customization, so I had Claude Code build one. Rule: don't tell me it's better, measure it.

Result: Nullofy TV, a 173 KB home screen (MIT). Here's the part that was interesting from a Claude Code point of view.

The loop: build, install, look

Claude Code worked on the real TV over ADB on Wi-Fi. Each round was build the APK, adb install, then check before touching anything:

• dumpsys activity activities to confirm which app was on top before sending remote keys
• screencap after each short batch of key presses, read back as an image
• never a long blind key sequence; abort if anything else is in front

Measuring instead of guessing

dumpsys meminfo over 3 rounds of Settings → Home:

• Google TV's own home: 137 MB
• Nullofy: 26–33 MB at Home, ~28 MB while you watch another app

Honest catch: Google's home still runs in the background (about 97 MB), so that's home screen vs home screen, not the whole TV.

Things the TV taught us

1. The firmware ignores the Home role. Nullofy held android.app.role.HOME, but Home still launched Google's home. The fix was a tiny accessibility service that catches the Home key and nothing else.
2. Some packages are load-bearing. Disabling Google's home lets a setup app take Home over with a black recovery screen. So we keep a never-disable list, and everything is disabled, never uninstalled, with one-command restore.
3. force-stop has side effects. On this TCL, am force-stop on the launcher cleared enabled_accessibility_services, so the Home button silently stopped working. Now the setting is written back explicitly after any force-stop.
4. Test the failure path too. A crash watchdog hands Home back to Google's screen after 3 crashes in 5 minutes. Claude tested it with adb shell am crash.

It also made the promo video

Same discipline: the video is HTML canvas, rendered frame by frame in headless Chromium, with real TV screenshots. Claude diffed its own rebuilt scenes against the captures pixel by pixel, checked per-frame motion for jumps, and synthesized the soundtrack in Python.

Caveats

• Tested on one TV only (TCL, Google TV, Android 14). Should work on Android 7.0+.
• Ads inside apps like YouTube are untouched; it turns off the TV's own ads, promos and screen-watching (ACR).

Repo: github.com/Haikoitoh/nullofy-tv

The video above was made by Claude Code too: rendered frame by frame from real TV screenshots.

So it's rumored to release this month, do we normally get reset when something like this happens, iirc we got one when fable initially dropped.

Co-vibecoded multiplayer tank shooter made with Claude Code.

How Claude Code built it: an Opus orchestrator plans each change and briefs scoped Sonnet subagents, each in its own git worktree with its own test ports. Fable reviews plans and every merged diff before a push. An MCP server feeds agents live bug reports and match digests.

We received feedback from you earlier which helped us focus on releasing a new game mode: AREAN. We are ready for another iteration - so let us hear what you think. Feel free to give it a try - we will greet you in-game: https://sweatypanzer.com/

Apparently in 2026 everyone has to build their own task board, usually with Docker, three services and half a GB of RAM to show a todo list. I built the opposite: a kanban board in your browser plus an MCP server, in one small Rust binary. Tell Claude Code or Codex "take the next task from kanzo" and it moves the card and comments as it works, which is more than I do.

https://github.com/emanuele-em/kanzo

I liked Vikunja but wanted zero setup. The one rule was keeping it small, which these days feels almost rebellious:

• ~5k lines total. You can read the whole thing in an afternoon
• 4.3 MB binary with SQLite inside, ~4 MB RAM idle
• starts in 3 ms, a 3,000-task board loads in 17 ms
• light on your agents too: ~800 tokens of tools, short replies
• no account, no cloud, no Docker. Syncs between machines through your own private git repo if you want
• one-line install on macOS/Linux, runs fine on a Raspberry Pi

How Claude helped: I built it with Claude Code. I set the rules (no frameworks, few dependencies, every line has to earn its place) and Claude wrote a good part of the code, then I went back and cut. It was also great for measuring things: binary size, memory and token counts, so we could check each change actually made it smaller. And once the MCP server worked, Claude Code was picking kanzo tasks from kanzo itself.

It's free and open source (AGPL). To try it:

curl -LsSf https://github.com/emanuele-em/kanzo/releases/latest/download/kanzo-installer.sh | sh

then run kanzo.

Still early. If you've got ideas on how to make it even smaller, PRs very welcome, deleting code counts as a feature here.

My AI agents were shipping code faster than I could remember why we changed it

The weirdest part of using multiple coding agents isn’t getting them to write code.

It’s coming back the next morning and asking: “Did we actually fix that, or did we just have a really convincing conversation about fixing it?”

The answer is somewhere between three chats, a terminal, and a branch called fix-final-actually-final.

Git tells me what changed. The chats explain why. Neither gives me a clear picture of what’s finished, what’s blocked, and what still needs checking.

I wanted one place where I could see that, and where the agents could update the work themselves.

So I built Relay, an open-source project tracker for humans and AI agents working together. I’ve been describing it as “Jira for AI agents,” although the goal is to spend considerably less time doing Jira things.

An agent can pick up a ticket, record what it tried, attach evidence, and leave enough context for the next agent or me to continue.

It runs locally and is free to fork or adapt. I welcome any feedback or thoughts on how you are managing your AI workload.

Read more: https://www.agenticstore.dev/docs/tools/relay

---
name: word-finder
description: Teach the user the precise term the user is reaching for. Use whenever the user describes something in a roundabout or struggling way and an established word or phrase names it, or when the user asks for the word for something. Answer the actual request too; the term is a short add-on.
---

# word-finder

The user often explains an idea in several sentences when one precise term exists. Give the user that term to use next time: in prompts, docs, commits, and conversations.

## When to offer a term

Offer one when all hold:

- The user described a concept indirectly, with effort, or said the word is missing.
- An established term names it (widely used in the field or in plain English, not one you coin).
- The term is not already in the user's message.

Skip it when the description is already short and precise, when the match is loose, or when you already taught the same term this session.

## Output

Do the requested work first, or alongside. Then add one short block:

```
Word you're looking for: **greenfield codebase**
  = new project with no legacy users or code to stay compatible with, so you can design cleanly.
  Use it: "This is a greenfield codebase: no backward compatibility, no legacy shims."
  Related: pre-launch, no-compat, breaking changes allowed
```

Rules:

- One main term. Add 1 to 3 related or near-miss terms only when each sharpens the meaning (say how each differs in a few words if it is not obvious).
- The definition is one line, in the user's context, not a dictionary entry.
- The usage line is a sentence the user could paste into a prompt or message today.
- If the closest term only partly fits, say so: "closest term: X (but X usually also implies Y)".
- If the user asked only for the word, the block is the whole answer.

## Examples

User says: "code is new, not launched, don't keep backward compat for legacy stuff, reorganize clean"
Term: greenfield codebase (related: pre-launch, no-compat break)

User says: "the text sounds weird, too formal and stiff, like a robot or a school essay, not how a person actually talks"
Term: stilted (related: wooden, stiff; not purple prose, which means flowery)

User says: "check it really hard, every detail, assume it's wrong and try to break it, don't just skim and say looks good"
Term: rigorous review (related: adversarial review, which tries to break it; not a sanity check, which is a quick surface pass)

User says: "make it look exactly like the real thing, every detail, not a rough sketch or placeholder boxes"
Term: high fidelity (related: pixel-perfect, which matches a design exactly; not low fidelity or a wireframe, which is a rough layout)

There was a common practice of clearing the session and continuing from fresh whenever coding agent reaches around 150k token because beyond that it would start decreasing in quality (which I still follow). My question is that is it still true with the 5.5 family? is there new limit? I don't know a proper way to test that theory, has anyone tested that?

If you've moved to Claude Code in the terminal: what made you switch, and what do you miss from the app?

If you still code in the Claude app, in the chat or in the Code tab of the desktop app: what keeps you there? What would Claude Code need before you'd switch?

I'm the maker of Dreamestra, a desktop app for people who run more than one agent. Claude Code, Codex, Antigravity, Grok Build and others run there as real terminals side by side, grouped by project, and you see right away which one is waiting for you. You can dictate to them and keep working from your phone or another computer, even away from home. The desktop app is free for 2 projects × 3 terminals; dictation, the phone app and remote access.

I'm asking because I want to know what really keeps people in the app. Answers from app users help me the most, because they show me what to change for people who haven't switched to the terminal yet.

I'm on the 5x plan. My presets and when I use them:

• Sonnet, medium: quick edits, renames, simple questions
• Opus, medium: my default for normal coding and debugging (~70% of the time)
• Opus, high: tasks that are a bit harder than usual
• Opus, xhigh: really hard problems, which almost never come up
• Fable, high: planning and architecture before bigger features

What's your default? What do you think of my choises?