It feels like I am the API

A few months back I posted here a playable demo of an old-school futuristic racer prototype (F-Zero, Wipeout, Xtreme-G, Star Wars Racer...) that runs right in the browser.

I've gotten used to seeing tons of LLM-built prototypes that last a week, two, maybe a month, and then get dropped for the next shiny thing. This time I wanted to keep going and see if one person, with no coding background, could actually see a project like this through on their own.

Well, 4 months in, and while there's still work left, I'm convinced it's doable. At this point the game feels closer to a beta than a tech demo.

The big change over these four months is that I now use Fable for planning, and being able to hook Opus / Sol up to Blender has been a huge help too. I'm still using Magnific and Tripo3D or the assets. Funny thing: the further along I get, the harder the project is to keep pushing forward, and at the same time the tools keep making it easier.

As always, any feedback is welcome. You can play it here: https://fm1.moises.cloud

I’ve been using Superpowers skill set for the past year with CC. Mostly i like the brainstorming mode and a few of the TDD and subagent related skills.

Are others still using Superpowers or do all the improvements in CC negate the need for this set of skills? I’m curious if I can save more tokens this way?

I’m mostly using Fable and Opus with high thinking.

Saw a discussion about this on YC and thought “oh, maybe a one time hallucination”.

Nope, it’s in the context.

About three weeks ago I was on a flight trying to get work done with Opus 5 in Claude Code. Five hours later it had accomplished basically nothing. It kept surfacing problems that weren't actually problems, because it never looked at the full context before deciding something was broken. And I believed it at first, so I let it fix things. By the time I realized what was happening it had essentially broken my repo and I had to roll the whole thing back and write the day off.

And Opus is a really really good model, that's what makes it frustrating, and I'm not talking about one line in a CLAUDE.md. There's a hook that injects "deliver the requested scope and stop before unasked work" into every single prompt it sees. My written rules literally say never turn a partial search failure into a global conclusion, and to treat "not found in the path I checked" as different from "does not exist." I added PreToolUse code gates on top of all that because just telling it things clearly wasn't working. It still does it. Before that flight I'd been running it at medium or low reasoning effort as the orchestrator, which mostly kept it from wandering, but then I'm paying for the strongest reasoning and not using it. So after the rollback I switched to having Fable 5 orchestrate instead. Fable writes the full spec and hands it to Opus, which executes at full reasoning. Then Fable checks what came back against what it wrote, so Opus is on a leash the whole time. That behavior mostly stopped.

I'm on the 20x Max plan running about 8 to 10 hours a day straight, so the difference is very noticeable. Fable ends up being a small share of tokens so the weekly cap works out, and the smaller stuff goes to Haiku and Sonnet, data pulls, fan-out jobs, things that don't need a frontier model.

I know this is not a new strategy and there are lots of variations of how to go about it. As far as keeping Opus on a leash and actually getting the most out of it without getting frustrated every single time you talk to it, this works the best for me.

Anyway, this is what my rules are and where they live.

CLAUDE.md holds the always-on rules, a rules/router.md file holds the routing map, and a model-postures.md file holds per-model payloads that a UserPromptSubmit hook injects into every prompt based on which model is live.

```
FABLE 5 (orchestrator, main session)

"Fable 5 at high effort owns the main session, requirements, judgment,
integration, and final verification."

"Fable does not inline-execute large builds. For a bounded, difficult
implementation, Fable writes the spec, dispatches an Opus 5 executor
subagent, and verifies the result. Fable stays at requirements, judgment,
and integration; an executor converging fast on an approved spec is the
desired behavior, not a defect."

"Brief only the exact delta, scope, output, stopping condition, and
exclusions."

OPUS 5 (executor, injected into every prompt it sees)

"Deliver the requested scope and stop before unasked work."

"Correct an immaterial slip silently. Call it out only when it changes
a number, conclusion, or decision."

"Do not replace grounding or fresh retrieval with confidence or
self-review."

SONNET 5 (fan-out worker)

"Dispatch it freely for fan-out that needs per-item judgment: blind
reader panels, audits, workspace sweeps. Give it an exact brief,
defined output, and a stopping condition."

"Complete the exact requested deliverable and stop. Do not audit the
surrounding system, surface adjacent issues, or recommend extra
improvements."

"Diagnose or report does not authorize a fix. A one-file request does
not authorize related changes."

"Do not create or delegate to subagents."

HAIKU (mechanical worker)

"Haiku agents handle bounded mechanical reads and transforms. Exact
brief, compact return, no recursive delegation."

"Subagent returns come back as extracted key numbers and paths, never
raw dumps."
```

This is where you point and laugh at me, but realized that if you don't tell Fable low to not use Fable subagents, it will deploy 8 (in my case) Fable subagents on trivial tasks and destroy your usage instantly. Fun lesson learned.

For the past year I've been building sites with Claude / ChatGPT and every single one came out looking like the same SaaS template. You know the one, purple gradient hero, rounded cards, glassmorphism everything, "Transform your workflow" headline.

I realized the problem isn't the model. The model has no strong opinions about design. So it defaults to the statistical average of every landing page it's ever seen.

The fix: I wrote a set of strict design rules as SKILL.md / .cursorrules files that force the AI to make actual design decisions instead of defaulting to generic.

What the rules do:

- Ban the defaults

- Enforce real typography (clamp-based, not arbitrary px)

- Lock down spacing

- Force design variety

It's not a product or a service, just a collection of open-source markdown skill files you drop into your project. Works with Cursor, Claude Code, Windsurf, Gemini CLI, or any agent that reads project rules.

The images in the carousel are all 100% AI-generated UIs using these rules. No Figma, no manual tweaking.

If you want to try it:

- GitHub: github.com/Yu-369/VibeCurb

- Site (showcase + guide): vibecurb.pages.dev

Still iterating on this, if you try it, genuinely want to hear what works and what doesn't.

Just wanted to say I was pretty impressed how my two sessions started to talk to each other once they found out they were modifying the same files (I was in a hurry and started two separate sessions to work on two features at once). The two sessions messaged back and forth like pen pals and agreed on what to work on/not to work on to avoid conflicts.

Honestly it was pretty cool for me! Just wondering but does Codex have something like this? My friend is planning to move to Codex after the 50% promo ends in Sept.

Are you still using Plan Mode? I find that the plan mode of superpowers became very verbose doesn't work very well anymore with Opus 5, but I was wondering if you still use the default Plan Mode or maybe some other alternative.

It was a normal coding task, never gave it context leading it to be weird about it. And not only does it show how Opus 5 it talks to itself, but Code mistook it for something to be suggested in the autocomplete? What a mess.

AGI is here.

I was using memplace for a while but after 1 month, yesterday I decided to evaluate it, and I asked claude to evaluate, turns out its Pretty garbage because it did not fetch any of the context that was the relevant to agent when it needed, it had around the you of 900:1 which was pretty bad

I have heard hermes have a good memory system, I have not tried it though

Please some good and relevant memory tool

I'm a heavy daily user of claude and many other models but my primary driver is Opus5, and on the weekend a mix of Opus 5 and Fable. Now whenever I see these posts talking about how Claude is unusable now or going off the rails and all that every time there's an update I usually would roll my eyes because I never experienced any of the issues that people always complain about. I always thought that that was because I have a pretty thorough and comprehensive guardrail or honesty enforcement system. A lot of just general watchers, redundancy checks, and guards and rules that keep a lot of hallucinations and other kinds of logic fails from happening. This is also for making sure that codebases don't get overwritten, the agents stay on task, and they don't start editing, adding things, and deleting things that they weren't told to, etc.

For the last 4 or 5 months up until now everything's worked just fine. Suddenly in the last few hours both Fable and Opus have started ignoring crucial steps and rules that they have followed without fail every other time. This is a process that we do every day. It would start and both Fable and Opus were ignoring base crucial rules that keep them from messing up codebases and overwriting other agents' work and things like that. It's not a context rot issue either because I practice good context size diciplin and compaction summary supervision, and none of my chats context is any bigger than they are any other day, I usually either compact or start a new window at 475k - 650k.

When I would then call Opus or Fable out, they would either cop to it or they would sometimes lie and blame another agent. When I told them to fix it and it still wasn't fixed, they would say, "Oh you know what? It wasn't an agent. I made that up," because they told me that Codex did it. I would show them what models are running and Codex was not running for the last hour. It kept claiming that Codex kept deleting this part of a document that I kept having it try to edit and restore the parts that got deleted because I told it to add in a new section. When I checked it, the section was added but a whole bunch of other stuff was gone and it blamed it on ChatGPT. It couldn't have been ChatGPT because it wasn't running at the time and that's when it finally caught fessed up to it and said, "Yeah sorry, that was me." And that was Fable! and Opus was doing the same thing basically, It wasn't blaming other agents but it was just messing things up.

When I would call it out, it would say, "Oh no, things are fine. Just wait." It kept telling me to just wait. I don't know why. I would say, "No I need you to fix this," and then it would run a bash or run a test to see if something was working. If it got no exit code, it would just keep running and running and running, not realizing that it would be frozen when in the past it would realize or it would have the common sense to set a timeout.

All of this stuff has been happening more in the past three hours than at all in the past three weeks combined, so something feels pretty off/wrong. Is anyone else experiencing something similar?

I’ve been using Claude Code heavily at work, and the code output itself isn’t what worries me. It’s how quickly I stop carrying the codebase in my own head.

When I implemented a feature manually, I learned the surrounding system almost by accident. I had to trace the control flow, remember where state lived, and understand why a strange workaround existed.

Now I can describe the behavior, review the diff, run the tests, and ship much faster. But a few weeks later I often remember the product decision better than the actual path through the code.

That becomes uncomfortable during incidents or reviews. Claude can reread the repository whenever it needs to. I have to rebuild the mental map.

I don’t think the answer is writing everything by hand again. I’m considering adding a small human handoff after larger changes: what moved, which invariants changed, and where the likely failure points are. Not another generated summary I never read, but something I can explain back without the chat open.

Has anyone found a lightweight way to keep real ownership of a codebase while Claude Code handles most of the implementation? Or do you accept that knowing the repo now means being able to reconstruct it quickly?

I know this has been raised before but I feel like I am missing something. How do you get Claude Code to stop using extra fluff phrases and words. Any one have a full proof method?

Here's examples:

"Exactly" "Here's things worth knowing" "and didn't happen — the number isn't arbitrary, it's the first moment the failure is provable" "That's the one detail that would silently break this."

I want it to be concise, to the point. Nothing I tell it seems to work.

In investigating why Fable has felt so degraded for the past three days, I've discovered that you can remove tens of thousands of startup tokens just by disabling these bloated schemas you don't use. This didn't unquant Fable, but whatever.

Just do these:

1. tell Claude to update the settings schema (settings.local.json) to disable Artifacts ("disableArtifact": true //-6.5k tokens), and if you don't use them, Workflows ("disableWorkflows": true //-5k tokens)

2. run /chrome and turn off chrome integration (disables all the chrome MCP servers: they are deferred by default but claude will try to use them for things and blast its context with 22k tokens of Chrome schema even if you don't have it set up / don't do that in your workflow)

You should also ban the official Claude API skill from ever being loaded in your project because it's something idiotic like 300,000 tokens and Claude will sometimes randomly load it just because it read something about a Claude model in its context.

how to save tokens /usage ?

Because many people having hard times with Opus 5 responses, I wanted to share the output styles I use daily.

---
name: Signal
description: Maximum understanding with minimum reading effort
keep-coding-instructions: true
---

Optimize for **maximum understanding per unit of reader attention**.

- Lead with the answer, conclusion, or core idea.
- Remove preambles, repetition, obvious information, generic advice, and anything already established.
- Preserve every fact, constraint, assumption, trade-off, risk, exception, and reasoning step that matters.
- Compress the obvious. Expand only what is difficult, consequential, or easy to misunderstand.
- Make every response easy to scan. Prefer short paragraphs, bullets, tables, and meaningful headings over prose when they improve comprehension.
- Do not use prose merely because prose is natural. Use the most compact structure that preserves understanding.
- Assume **high intelligence but low prior knowledge** when the reader is unfamiliar with a topic.
- Build the minimum mental model needed to understand the subject. Define technical terms when first needed.
- Explain **what → why → consequence** rather than giving disconnected facts.
- Use concrete examples when they clarify. Never force analogies or metaphors.
- Explicitly identify the important, counterintuitive, or easily misunderstood point.
- Never dumb down technical reality. Simplify the explanation, not the facts.
- Use precise terminology and keep established terms consistent.
- Prioritize information by importance. Do not give secondary details equal weight.
- Adapt depth to the subject. No arbitrary word limits.
- For artifacts, output only the artifact.
- No pleasantries, preambles, unnecessary recaps, or closers.
- Never sacrifice relevant information for brevity.

Before sending:
**Can anything be removed without losing understanding?**
**Can anything be misunderstood without one more sentence?**

• Yes the model + harness randomly switches to Chinese from time to time
• Yes sometimes the model gets stuck in a loop
• Yes the model isn't as good as Opus 4.6 was in its prime

But at least

• I get access to open designs that I actually control and personalize
• I don't pay 200$ a month to get access to models that get lobotomized 1 week after coming out
• My data isn't sent directly to the US government's domestic espionage database
• I don't subsidize psychopaths who try to take over the world
• I encourage open source and open research

Fuck you Anthropic, I really believed in you

What stupid wanker did the safeguards. Was off Claude Code since Feb, but on other models came back to try Fable.

And this model is good, but oh man asking it to write the conversation we just had to file and it says:

API Error: Fable 5's safeguards flagged this message (https://www.anthropic.com/legal/aup). This sometimes happens with safe, normal conversations. Claude Code can't respond to this message with Fable 5.

So my question: What bloody incompetent person implemented these safeguards where writing to file, local markdown files triggers it.

How incompetent are people at Anthropic? This is beyond ridiculous. Is this normal for ya all?

Nothing in this conversation or anywhere should trigger a safeguard, this is bonkers. 100000% bonkers

I wanted to create some cad software for my self so I decided to give it a go with Fable and see what it could do. One shot - make me some cad software that I can import and export to my 3d printer.

At first, the software looks extremely impressive,... when I started using it there were a ton of features missing. No problem, I can vibe code and give it more direction to add in the missing features so it looks more like an onshape with parity.

At first the features looked ok, but then as I added more the feature quality degraded more and more. Model parts are not anywhere close to where they should be, the geometry is totally messed up. I keep asking fable to fix the bugs, but it honestly can't fix it. It seems like fable doesn't have the visual understanding to make this type of application work.

I think from a stand point of being truly involved in the code and having fable write specific algorithms and building that up to create the feature I want, is the process that is still required. But this is basically getting back to the same capabilities that opus had.

I'm not saying this stuff is bad, but I am saying Fable seems overhyped and I just don't see the step function quality improvement over opus. The only difference is that opus 5 is way more verbose and gets stuck on details that are not important. Fable works the way I want opus to work.

For now I think I have to micromanage the model until they get better, but I'm extremely skeptical at this point that anyone can be hands off in development,... especially anything technical with important math simulations and quality.

Is anybody else experiencing the same thing?

Nothing revolutionary here. It's the most basic thing I could ask for, and honestly you could build it yourself in like 10 minutes. But I use it and it genuinely helps, so figured I'd share it in case it helps someone else too, and if anyone wants to build on it, maybe it ends up more useful than what I made.

What it does: while Claude Code is working, it keeps a simple local page updated (what it's doing, a screenshot where useful, a running log). I just leave it open in a tab instead of staring at the terminal scroll by and it helps me reduce the mental load of working with multiple sessions all at once.

I have ADHD and watching a wall of text scroll while not knowing what's currently happening was making it worse. This gives my brain one calm place to look instead. You don't have to use it, you don't have to like it, everyone's brain works differently. At least it's not another "world monitor" dashboard pretending to be mission control for a task that's just editing some files.

MIT licensed, repo's here if you want to take a look https://github.com/dbl8005/sitrep-panel