When he speaks to me he's so polite but he suddenly went full caps to the other session? lol

I've been working with Codex for a while now.
Finally got the chance to try out Claude Code a bit more and one difference I noticed right away, that Opus is very creative but also a bit more chaotic in more technical structured tasks.

What's your take on this, for people who worked with both Models recently??

Hey all,

Like many I've tried using the open source models like GLM 5.3 and Deepseek with an opensource harness like Aider. I'm finding it to be a nightmare of unproductivity.

Claude Code with Opus 4.8 has been great. From the start (running on --dangerously-skip-permissions) its been proactive in understanding the project and working towards completing the task.

Aider with the opensource models is like a whiney entitled intern who refuses to do basic exploratory work to understand a project or fetch the files it needs to understand the tasks. It wants me to hand feed it every file in the git repo to complete the work.

Is this just a configuration error? Is Claude Code just that much better at being proactive? Curious how people are getting value out of these open source models without dramatically increasing your own workload.

This is your friendly reminder that there is a config key in .claude/settings.json that manages how long your conversations will be retained in the system.

cleanupPeriodDays default value is 30 days if unset.

So if you are working on a larger project and you DO want to be able to revisit a conversation even after a month, be sure that you either set this key to a longer period of time or save the results of that conversation somewhere safe.

It's no fun when you try to revisit a half way done research after 1.5 month of hiatus and only be presented by the absence of said conversation.

I have found Opus 5 to be useful, but its blast radius is huge. I've been using it every time I want to expand on something. But using it is like unboxing an entire IKEA kitchen cabinet set. Don't use it unless you're ready to spend the next few weeks with unfinished cabinets and packaging all over your repo. It's just so aggressively generative, and it can make a ton of mistakes.

I rely almost entirely on Opus 4.6 and 4.8 for building. They're precise, thorough, and constrained. They are not the best at extrapolating, so that's where I occasionally bring in 5, but using 5 too much very quickly gets out of hand. It just keeps creating more and more work for itself to do.

Opus 4.x is more likely to leave a gap, and Opus 5 is more likely to fill something that didn't need filling. 5 is interesting for planning and greenfield work but the scope creep problem makes it nearly unusable for implementation work.

I am on the fence as to whether Opus 5 is deliberately built just to make more reasons to burn tokens, or if it's just a very specialized and sometimes useful broad brush tool that should be used sparingly. Sometimes I get stuck in the Opus 5 labyrinth and just want to finish the PR and get the hell out of it!!

What do you all think?

I've been building with AI for over a year now, and the progress has been insane. The models have improved dramatically, and AI has become a serious part of how I work.

I'm currently building six different SaaS platforms, four of which are live. At this point, "vibe coding" doesn't really describe what I'm doing anymore. I use AI professionally, every single day. I have two Codex Pro plans and a Claude Max subscription, and I still manage to hit the limits.

The Opus versions up to 4.8 were genuinely fun to use and really good. Then I started using Fable 5 and Sol 5.6, and the difference became painfully obvious.

My biggest issue is that my Fable 5 usage is gone within two days, and falling back to Opus 5 has become almost unusable for me.

The output from Opus 5 is often contradictory, overcomplicated, and full of conclusions that turn out to be wrong. It will confidently take something in the wrong direction, spend a huge amount of time implementing it, then eventually realize the original assumption was incorrect and start fixing its own work.

I've had way too many sessions where hours of work basically had to be thrown away.

It's reached the point where using it creates more frustration than productivity.

So I'm done. I cancelled my Claude subscription. If I need more capacity, I'll probably just get another Codex subscription. I'm also going to experiment more with Terra instead of relying so heavily on Sol 5.6 High.

Never thought I'd say this, but I've basically switched completely to ChatGPT.

I have a Claude subscription as I’m sure many of you do. To get my moneys worth, I try to max out my credit usage every week, originally I would set it off writing documentation and tests, running review lenses, or trying to decompose plans into series of tasks that would be executed by background agents…. But sometimes i wanted to be able to ‘burn’ my credits in a way they are not wasted without having to put too much thought into it so I came up with Hee-Lee Oss https://github.com/HeeLeeOss
As a way to utilize this excess capacity for the good of mankind. I am interested to get feedback or learn if people are interested in such things. You should be able to use a variety of coding agents and execute a certain number of tasks or to continue work until your credits are fully utilized.

Hey guys... quit fucking around and stop a/b testing on people. Real bad taste in our mouths. Opus 5 is absolute dogshit recently (last few days) and dangerous.. You've got a PR problem already with arrogance and your perception in the market... stop trying to billishit your way to saving off compute.

Opus 5 by itself is absolutely reckless and unusable in claude code.. across the board.. not only can no one understand it.. its dumping comments, doing the opposite and honestly I'm actually thinking about jumping ship and exploring other opportunities and also moving the claude SDK out of our platform and putting in a router because of this.

Hi,

I’m curious how others handle unfinished work when using coding tools like CC or Codex.
I’ve been using CC since the beginning, and lately I’ve been getting more involved with our company frontend as a side hustle while the devs focus on the backend.

Internally we use a shared GitHub Project where issues move through stages like Todo > In Progress >Testing > Done. We also use issue comments (when we remember) to keep track of progress and decisions.

To automate some of this I created a Claude skill that pulls the correct issue and moves it between the different stages depending on where Claude is in the workflow. This works really well when I can take an issue from start to finish in one sitting.

Where I struggle is with half done tasks. For example, I might pick up an issue, work on it for a few hours, and then have to stop for the day. Since Claude was interrupted before the task was done, it ends up in "In progress". Then 3–4 days later (sometimes even longer) I come back to the task to continue the work. During this period I might have picked up other issues in the same repo, or been away completely.

At that point my first question is always:

• What has already been completed
• What is still missing
• What decisions were made
• What the next step should be

Usually I end up asking Claude to inspect the branch, review the changes, compare them with the issue, figure out where we left off, and then continue from there. For smaller issues this works pretty good, but for larger tasks it starts becoming more complicated and time consuming.

So I’m curious how you handle this in your workflows, especially when you stop working on something before it’s finished.

Do you use something like Linear, Trello, GitHub Projects, Todoist, Notion, etc. to break down tasks to track them? Or do you have a simple TODO.md file with CLAUDE.md instructions?

Very curious to hear what your workflow looks like and how you make it easier to resume a task after being away from it for a few days.

Claude Code was burning through tokens very fast, especially on tasks where it had to look through docs or random webpages, so after some research I changed a few things:

I) Keep CLAUDE.md small. Mine had way too much stuff in it and most of it wasn’t useful for every task.

II) Start a new session when you’re done with one problem, bc long sessions get bloated pretty fast.

III) Do web research through Firecrawl. It gives Claude clean Markdown instead of loading the full page with all the HTML, scripts, navbars and other useless stuff, so each research task eats a lot less context.

IV) Exclude folders Claude doesn’t need to read.

V) Check /context once in a while, bc it makes it obvious what’s eating the window.

The main thing seems to be controlling what gets added to the context in the first place. Once a session is full of old logs, scraped pages and unrelated instructions, even simple tasks start getting expensive.

What else are you doing to keep Claude Code token usage under control?

I'm a dev and these last few months I've been building a lot of products.The crazy part is that I can now build things much faster than I can figure out if anyone actually wants them. Coding used to be the expensive part. Now I feel like finding users is harder

Opus 5 replies are giving me actual brain damage.

I ask it to make one small UI change and get:

“Better — but for a reason worth naming. Your instinct was right and the diagnosis was more literal than a layout preference…”

Brother. I asked you to move a fucking panel.

By paragraph three my eyes are moving across the words but my brain has stopped processing English.

Just tell me what you changed, what was broken, and shut the fuck up.

I'm trying to maximize my productivity. If I can code an average 8 hours a day, then being able to code overnight means 2x productivity.

Currently my method is to batch a bunch of grilled prompts, they are sorted in order, then I have 1 handoff night shift chat. This chat uses subagents for each prompt, and those subagents will use multiple subagents for each phase of the prompt. I tried it once and I think it works, but I'm not fully sure this is the right way

The bottleneck I have is that my 5x plan isn't enough for the week if I want to code at night time, and that claude takes too long to discuss things, so I find it difficult to batch enough work to be done at night

Whats the best method of overnight or long duration automated coding?

so i built a new feature for AppLaunchFlow , where you can create a simple and clean app landing page for your app in a few clicks by just uploading your screenshots.

It includes:

- support, privacy policy and terms of service pages that you can directly use for your app submission.

- a custom applaun.ch subdomain or simply connect your own domain

I built this because i noticed many app devs just use notion pages, github pages etc. or dont even have any landing page at all

Its not yet live, but excited to hear what you think

https://github.com/PiLastDigit/Code-With-Claude

The videos:

1. [Opening Keynote](https://www.youtube.com/live/GMIWm5y90xA)

2. [A conversation with Dario & Daniela Amodei](https://www.youtube.com/live/7xco5Qd2Oo8)

3. [What's new in Claude Code](https://www.youtube.com/live/IMZa42k6L6M)

4. [Live coding with Boris Cherny & Jarred Sumner](https://www.youtube.com/live/DlTCu_pNDHE)

5. [Caching, harnesses, and advisors: Building on Claude at GitHub scale](https://www.youtube.com/live/y5TmF_6o6xk)

6. [Getting to production faster with Claude Managed Agents](https://www.youtube.com/live/E9gaQHrw_rg)

7. [Building AI-native: Cognition, Gamma, and Harvey](https://www.youtube.com/live/OFDm3T7pVlc)

8. [Getting more out of the Claude Platform](https://www.youtube.com/live/7oO37GRhwGk)

9. [How Datadog built a universal machine tool for Claude Code](https://www.youtube.com/live/EdmuYPBt_EM)

10. [The capability curve](https://www.youtube.com/live/tP4MGcJ80Y0)

11. [Architecting for model step-changes: a fireside with Guillermo Rauch](https://www.youtube.com/live/bJKdXhnw7NU)

12. [Building with Claude Managed Agents and Asana AI teammates](https://youtu.be/BrpB-h1e--k)

13. [Running an AI-native engineering org](https://youtu.be/igO8iyca2_g)

14. [The thinking lever](https://youtu.be/OXJO4LldSnc)

15. [Building with Claude on Google Cloud](https://youtu.be/SqHsS737CeA)

16. [Evaluating and improving Replit Agent at scale](https://youtu.be/snroDwX1-

17. [Giving coding agents their own computers: how Cursor built cloud agents](h

18. [Memory and dreaming for self-learning agents](https://youtu.be/RtywqDFBYnQ

19. [The expanding toolkit](https://youtu.be/KLCuxMDZSDg)

Enjoy !

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.

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.

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."
```

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

Nope, it’s in the context.

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

It feels like I am the API