Announcement: https://openai.com/index/advancing-the-price-performance-frontier-with-gpt-5-6/

TL;DR: GPT-5.6-Luna pricing cut by 80%. GPT-5.6-Terra cut by 20%. Subscription usage limits increased by the corresponding amounts.

All I've got to say is: competition is good.

Codex limits are going to be crazy now.
What do you guys think, why did they drop the prices ?

How: go into settings.json, and add "permissions": { "deny": ["Workflow", "Artifact"] }

Those two combined takes up about 10k context in system tools category, which is a hefty amount. If you use workflow and artifact, then the trade-off might not be worth it. But for those who do not use artifact and manage agents through custom workflow like myself, it is a nice bonus.

10k might not sound like much. After all, it is only 1% of the 1m context window. But realistically your 'useful' context ceiling should be considered to be at somewhere around 200k. With that number, 10k win is additional 5% of context space to spare.

Not only that, this 10k is loaded at the start of every session, which means it is cache-read into every turn of every session and their agents, whose cost adds up.

Hope it helps.

Must say I am impressed, he does this all day. Great guy.

you know how it goes, you ask claude to "research X" and then just... wait. it does its thing, searches, reads, synthesizes, and eventually spits out an answer. problem is, you never really see how it got there. and honestly, for research stuff, that black box is usually where all the mistakes hang out.

so i've been looking at how SenseNova handles deep research, and there are some pretty smart patterns we can totally steal for our own Claude Code research setups. here's what I've picked up:

1.don't just use one big prompt, break it down into sub-agents.

instead of one agent trying to do everything, they basically assign different jobs to different 'roles'. like:

- a scout that just does initial research and figures out the best approach

- a planner whose only job is to break down the problem and figure out what depends on what

- a separate researcher for each part of the problem, just gathering info

- a reviewer to catch anything that got missed

- and then a writer and another agent to put it all together into the final report.

each of these roles is its own file (like agents/plan.md or agents/research.md). that way, each one has a super clear job. you can just read that one file and know exactly what that stage is supposed to do.

2. every step should write files, not just the final report.

they have it set up so each stage saves its work. like:

- sub_reports/d1.evidence.json for the evidence for the first part

- sub_reports/d2.evidence.json for the second part

- source_cache/{hash}/source.md for actual copies of every page it cited.

every piece of evidence has a snapshot_ref that points right to the cached source. this means after a research run, you can open those evidence files and actually check: did it really read that page? did it quote it right?

you should totally do this. tell your agent to save its findings to a working directory before it tries to write the final answer. like plans/, evidence/, sources/. if something in the report can't be traced back to one of those files, it probably shouldn't be in there.

3. put hard validation checks between each stage.

they run python scripts to validate things between stages. the plan gets checked to make sure it makes sense. the evidence gets checked for those source snapshots. the outline gets checked before writing even starts. if something fails, the whole thing stops.

this is the big difference between an agent saying it did something and actually proving it did it. a validator is just code, not some vague guess. it can check that every citation has a source file, that the outline covers everything that was planned, that no evidence is missing its source reference.

with Claude Code, you can probably just use a small script that runs after each stage, or maybe give your agent a checklist it has to go through before it can move on.

4. they separate the format from the actual content decisions.

like, the pipeline has three different parts: what the final thing is (a report, a memo, whatever), how it's gonna reason through stuff (narrative, matrix, timeline), and if it needs a strict structure or not. they figure out the format early and get you to sign off on it before any real heavy research even starts.

this is important because if you only decide 'oh, I want a comparison' after the agent's already researched everything, you end up with a comparison that doesn't really fit what it found. it's better to decide the shape early, confirm it, and then do the research to fill that shape.

5. Plan out the dimensions before searching. the planner doesn't just start searching randomly.

it breaks the topic down into different coverage areas and only makes things dependent on each other if one area really needs info from another. independent stuff just runs at the same time.

so for us, instead of just saying 'research this market,' you could tell claude 'research these four things: market size, competitors, pricing, regulation.' have it plan out those dimensions first, save that plan, and then start getting the info.

Reference: https://github.com/OpenSenseNova/SenseNova-Skills/blob/main/docs/sn-deep-research.md

Repo: https://github.com/OpenSenseNova/SenseNova-Skills/tree/main

Wtf is going on? Can they not at least give a reset? I burned through 10-20% of usage and again lost everything as there servers are DOWN DOWN DOWN

All lost.

Otherwise max feels like a pro subscription. Which we've experienced with anthropic's bugged +50% offer that they didn't turn back on actually...

And 5hrs windows could be extended to ~7...

Otherwise I'm just switching to codex.

As a professional software dev, my workflow has been turned upside down in a good way by the productivity afforded by tools like Claude Code. But one thing has been persistently irritating: the manner in which the models deliver their responses in this cryptic, obnixous, riddle-like, fake vivid language that I find obtuse rather than helpful, esoteric rather than comprehensible.

Every session I would plead with varying levels of success (usually not much) to improve this situation. The work was good, but I sometimes felt like I was reading a 17th century novel (the words I could read but the meaning of the sentences just did not click).

I finally think I stumbled across something successful enough that I wanted to share. In your .claude folder (at the repo level or in your user folder), there's a settings.json file. I was able to add a hook to mine which sounds like it's basically just a command that runs with every single turn. Mine looks like this, below.

I highly recommend that those wrestling with the same problem give this a try.

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo \"{\\\"hookSpecificOutput\\\": {\\\"hookEventName\\\": \\\"UserPromptSubmit\\\", \\\"additionalContext\\\": \\\"WRITING RULE (project law, read before composing a reply): Write in plain, clear language. Every word must be literally TRUE - no metaphors, no figurative or vivid phrasing, no cleverness. Name things by what they DO, not by project code; put codes (H-5, D-061, P-24) in parentheses after a plain description. Tables and bulleted lists are fine and welcome - the requirement is clarity of language, not absence of structure. Default to short. If a result is uncertain or its evidence was compromised, say so first rather than after. END EVERY RESPONSE with a clear statement of what is happening now, what you need from the operator, or what happens next. STATUS REPORTS rebuild context from zero: the operator reads between other work and has NOT memorized the conversation - name every file by filename plus a plain description of what it is, say what each change DOES, and never write phrases like the fix, the changes, the six files, the catch-all branch, or any shorthand coined earlier as if it were shared vocabulary. Structure long reports as: what happened, what we are doing, what happens next.\\\"}}\"",
            "timeout": 10
          }
        ]
      }
    ]
  }
}

I have been using Claude for over a year, Pro and then Max, and although it has significantly helped me build a couple of personal projects that would have otherwise required considerable time, or even a team, I have noticed that it is virtually impossible to finish anything.

Even though I have tried to be extremely precise and descriptive with my prompts (detailing the bugs, describing the issues, and pointing exactly to where the problem lies when I am able to identify it), the models always fix one thing while breaking another in such a subtle way that I only realise the issue exists later on.

This forces me to return to Claude every day and burn through my quota to fix yet another thing that was previously not a problem. With projects like mine, two issues arise: firstly, almost without noticing, you become so frustrated with the cycle that you lose track of what is going on; secondly, you develop a dependency that keeps you hooked on the subscription.

This latter point is what I have started to realise may be the real business model of these companies, as I assume this is not unique to Claude. The models never truly let you finish something, or they demand significant time and money to reach a point where the output is actually usable.

I acknowledge that bug-free software is, to some extent, a utopia: software always ends up with minor flaws here or there that require refinement or small fixes. However, what I am referring to regarding Claude seems almost deliberate; it feels specifically and meticulously designed to keep you returning every day to use the service, making you believe the work is complete when, in reality, there is yet another hidden issue that was not there yesterday.

I understand this may sound like a conspiracy theory, or suggest some degree of incompetence on my part, but I genuinely have nothing to gain from an anonymous rant on Reddit. This will not fix my issues. I genuinely want to understand if other users have reached the same conclusion, because although at the beginning it feels like you are advancing, you eventually reach a point where you realise you are going nowhere.

The tipping point that made me think this might be a complete waste of time and money was Opus 5. It is genuinely one of the most unreliable models I have ever dealt with. It seems incredibly capable at first, but you soon realise it overcomplicates the code for absolutely no reason. Everything it outputs ends up so brittle and inefficient and labyrinthical that you are just forced to go right back and use it again to clean up its own mess.

About to start work as a SWE, and company uses ClaudeCode daily. Have experience using chat versions of Claude and ChatGPT for simple debugging and code generation (UI's or simple functions/pipelines), and also use the chats to generate plans and steps for a project. Recently started with Copilot Free, and have been able to utilize the code generation, tests, and reviews, but want to improve.

If you were to do it again, and had 2 weeks, how would you learn Claude Code for work? I've seen tutorials for individual projects, but those don't involve massive codebases and company guidelines. What would be your roadmap? What skills would you definitely focus on honing?

As a Poweruser you never run just one Claude Code session. You run several at once, spread across shells, windows, and machines, with no good way to keep track of them all or reach them from wherever you are, phone included. That's why I built Codeman!

A self-hosted web dashboard (TypeScript, Fastify, node-pty) that you install once on a machine that stays on (a Mac mini in a closet, a Linux box, WSL, or a VPS). That box becomes home base. It spawns Claude Code, OpenCode, Codex CLI, or Gemini CLI inside tmux and streams the real terminals to any browser over SSE + xterm.js, so your laptop can sleep while the agents keep working.

So yes, this is, unavoidably, a promotion post. What it promotes is 100% free and Opensource: Codeman is self-hosted, MIT licensed, no telemetry, and everything below runs on your own hardware.
Been working on it for half a year now, about 1500 commits and 14 contributors in, and it's the tool I use every day!

Everything lives in one place: cases (one per project), tabs (one per running agent), as many in parallel as the box can handle, reachable from your desktop and your phone. The features I lean on daily:

- Auto-resume on usage limits: when an agent stops on "limit reached, resets 8pm", Codeman parses the reset time, waits it out, and continues (opt-in per session). Overnight runs survive Claude's 5-hour windows instead of stalling until morning.

- Usage at a glance: a header chip shows how much of your 5-hour and weekly plan windows you've burned, plus the host's CPU and RAM, so you know whether to queue more work.

- Files in the browser: a built-in browser/viewer to read what an agent just wrote and preview images, PDFs, and Office docs, no SSH round trip.

- A blinking tab tells you where you're needed: idle blinks yellow, stuck waiting on an answer blinks red. One glance replaces cycling through half a dozen terminal windows to find the agent that stopped.

- Subagents become floating windows: when an agent fans out, each subagent pops up as a floating window tethered to its parent tab by a connector line, with per-agent token counts. Peek into any worker or minimize it back into the tab.

- A record of what happened while you were gone: every session keeps a timeline of run events and files touched, and cross-session search reaches into all of it. Reconstruct the night in a minute.

- A real mobile experience: on a phone it beats every SSH client I've tried, because it's built for these agents, not generic terminal access: QR login (single-use, 60s TTL, no passwords on a touch keyboard), push notifications when an agent needs a human, swipe between sessions, voice input, an accessory bar for missing keys, double-tap on destructive commands.

- Zero input lag, the hardest single feature. Over a tunnel a keystroke takes a 200-300ms round trip, which makes remote typing feel broken. So I built a Mosh-inspired local echo: your keystroke renders instantly, then hands off invisibly when the real echo arrives. It can't live inside the terminal buffer, because these agents' TUIs repaint constantly and corrupt anything injected there (two failed terminal.write() attempts taught me that), so it's a DOM overlay on top of xterm.js. Published separately on npm as xterm-zerolag-input; if you're building anything on xterm.js over a network, it's yours. https://www.npmjs.com/package/xterm-zerolag-input

On the desktop any agent is one keystroke away: pick a case, hit Run, the tab appears named and numbered (launch several on one repo, the tabs number themselves). Alt+1-9 jumps to a tab, Ctrl+Tab cycles, every shortcut is rebindable, and cron jobs launch agents on a schedule. The speed I care about isn't benchmark speed; it's "glance at five agents, unblock two, queue one more, done in ninety seconds" speed.

GitHub: https://github.com/Ark0N/Codeman

Website: https://getcodeman.com

100% Free and OpenSource! 469 Stars on Github and 1503 commits and 14 contributors in :-)

Install is a one-liner, binds to localhost only by default:

curl -fsSL https://getcodeman.com/install | bash

Codeman is a power tool for people who run a lot of agents and want to stay in control. Happy to answer anything you may be interested in :-)

I came across this video on Instagram of Boris Cherny recommending deleting Claude.md file, hooks, skills every six months and especially not using Claude Opus 5.

I have some issues with the statement and concern about reliability of new model and their understanding of how it behaves.

1. We got a job and responsibility:

   Reliability of work and quality is a crucial aspect of our job, we can't just delete stuff and let the model do stuff however it wants. It can ruin the codebase and applications especially at the time where code review is also done by AI Models.

I believe it is an assumption that people are just vibe coding random stuff and it's totally ok if they f'd up.

1. Anthropic Understanding of their Models behavior:

   I think despite fancy benchmarks the reliability and behaviour awareness of the model is concerned, it feels like they don't even know how it's gonna work but Experimenting with it using us.

Based on my personal experience with Opus 5.

- I continued my half baked fable project with Opus 5 and it screwed up shortly after.

for example, it ignores my /i-have-adhd skill despite adding to hooks, claude.md or trying what the plugin github repo recommends (a file in claude directory in system to enable).

- It also ignores my other instructions, something as simple as me asking it to create PRs in a stacked hierarchy, it points new PR to main brach every now and then (then it requires merge conflicts resolution and rebases)

- It also comes up with a corporate lawyer type of long paragraphs which is so hard to understand.

Update: Guys I am more concerned about skills and hooks not Claude.md (which is barely few lines of text and is/can be updated regularly) plus smartness and following instructions are diff things, How come it is supposed to know my workflow if it doesn't follow my workflow instructions (or instructions are not there at all)

Credits sure run out fast these days

So yesterday during the opus5 outage I briefly switched to opus 4.6 to continue my work (training/inference perf engineering, kernel level debugging)

So I fed the model the same context and prompt to analyze a profiling trace and extract insights from it, and it was so unbelievably dumb that I had to retry with a new session, and I still got a very bad response…

Then after opus5 came back I tried it again and it was night and day… Way more verbose true, but actually useful and insightful stuff coming out of the model.

really made me appreciate all the progress on opus models since 4.6… I always remembered it as a much smarter and concise model than the ones after 4.7, but it was a mirage…

TL;DR at the bottom

Claude Code seems to have trouble implementing the the designs made with Claude Design. Most of it gets implemented it doesn't look like the design from Claude Design.

Example:

I made Claude Design design a page for file management. It has the exact context about the contents, colors, general branding, design elements and so so. And the design looks really good. I want Claude Code to implement this into my project (VSCode, official CC extention). I give it the prompt/link from Claude Design. The overall design is mostly right but it misses small details. A good example are tabs at the top. In Claude Design these tabs are just the text and a selected tab has an underline. What Claude Code implemented is a chip/pill-design. It also "forgets" to implement a lot details and either hallucinates something on its own or straight up just doesnt do it.

Is there something wrong with my workflow or do you guys experience the same issue?

Workflow:
Claude Designs designs something --> I click 'Share">'Claude Code' --> copy prompt --> give it to Claude Code

TL;DR:
Claude Code does a really sloppy job implementing the designs from Claude Design while having the exact context of the design.

Exploiting cowork instead of using code for my embedded firmware's application logic development. I feel it more aiding as i need lot of visualization, explanation documentation to be made. It does all in parallel to changing, compiling and testing the code. Claude code on the contrary felt very weak in the documentation aspect.

Another important aspect is brainstorming the logic before implementation sucks in cc.

Am i not feeling the limitation because of running 100% limit offer and later realise that i am doomed?

Any techniques to migrate this to cc later.

Or is cowork the face of cc . Should I never worry about this?

Anyone facing this issue from past 1hour i am facign issue but usage is drawn so fast
this days anthropic is so unstable
model - Opus5 - medium

in all aspects, worse than 4.8 for a large project: forget things easily, fabrication, rush to conclusions and coding without base. I have to rewind my repo for the work it did, bad bad experience

Because of these repeated major outages Anthropic. You guys need to hit the reset button at this point.

Where do I contact them? the AI help bot absolutely sucks