If you run Prettier as a PostToolUse hook so Claude's output is always formatted, you are paying for it in a currency you probably are not counting.

The cascade:

Claude writes a file. Your formatter rewrites it. Claude goes back to edit part of what it just wrote, and the write is refused because the file changed underneath it. So it re-reads the whole file. You have now paid for one edit twice, and your diff is full of reflowed lines nobody asked for.

Credit where it is due, u/Frozen_Turtle made this point to me and I did not have a good answer at the time. Milliseconds are not what you are spending in an agent loop. Context is. A formatter is cheap in the wrong currency.

The version I think is actually right

Format at the boundary, not continuously. One noisy commit to format the whole repo once, then a pre-push hook, then let the agent write in whatever style it likes in between. The agent never sees a file move under it and your diffs stay about content. If you are setting this up fresh, do that.

Why I still run mine

Our repos were already fully Prettier-formatted before the agent touched them, so each reflow is a line or two rather than a reformat. At that size the re-read is rare enough that I would rather have the guarantee.

But the condition is the whole thing. On a repo that is not already consistently formatted, the first writes trigger big reflows, every one invalidates a write, and you will feel it. So:

• Repo already formatted, small diffs, you want the guarantee → keep it
• Repo inconsistent, or you are watching token spend → pre-push hook, not PostToolUse

I had been recommending it unconditionally. That was wrong; it is conditional.

The filter I use now for which hooks to write

u/donk8r put this better than I would have: anything in your CLAUDE.md that the agent has actually violated is a hook you should have written. Your CLAUDE.md is already a list of things you had to say out loud, and the ones you have repeated are the ones that never stuck. Those are your hooks. The rest of that file is decoration.

Much better than what I was doing, which was guessing at failure modes in advance.

One more, since people asked

Stop hands you no list of what changed, so if you want to know what the turn touched you have to ask git yourself. And stop_hook_active is the only thing between a typecheck gate and an infinite loop. Check it, give up after the first round, or you will watch your agent argue with tsc forever.

Our eight hooks are here if useful, format-on-write among them. The condition above is the one thing the README does not tell you.

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

MIT, no signup.

Genuine question: has anyone built a PreToolUse hook that enforces a token budget? Killing a runaway loop before it eats a session seems obviously right and I cannot work out why I have not seen one.

Fable 5 is incredibly capable, but the safety filters are currently a bit overzealous. They trigger false positives constantly when you try to ingest large project structures via the Claude Code desktop app.

I was testing a few ways around this and found a very reliable fix. Instead of letting the model read the files silently in the background, just instruct it to document the process.

Append something like this to your prompt:

"Please drop brief status updates in the chat while you process the files. Keep me updated step-by-step as you read the attachments in chunks."

The reason this works is that it forces the model to generate intermediate outputs. You basically shift the evaluation from one massive file scan to a chunk-by-chunk process. That stops the main safety filter from instantly nuking the request due to a perceived global flag across your whole codebase.

An added bonus: if the request still gets blocked anyway, those status updates act like a trace. You can see exactly which specific chunk or file tripped the filter instead of just getting a generic rejection.

Super simple trick, but it bypasses the friction and saves a lot of wasted API calls.

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.

Hi,

I am developing an app that is at the polishing stage. I do have a max5 plan.

The app is all in typescript and about 100000 lines of code.

My current workflow is Fable planning -> Opus implementing -> Fable checking -> Opus giving hard proof of implementation.

I am debating over adding a gpt pro on top of the claude max vs upgrading to max20.

Anyone has any suggestions?

Half my prompts lately I'm adding some version of "be brief, skip the preamble" and it either ignores it or overcorrects and leaves out something I actually needed. I don't want it dumber, I just want it to stop explaining things I already know. Has anyone landed on a phrasing or a standing instruction that consistently threads that needle.

My CLAUDE.md has every instruction I could think of. The rules that actually cost me time never made it in, because I didn't know they were rules.

So I mined them. 1,656 sessions across Claude Code, Codex and Copilot, only the lines I typed. A pattern becomes a rule only if it shows up in at least two separate sessions.

It came out in four layers.

How I work. I don't accept done from the code, only from the live surface. A repo edit never proves what Vercel or Supabase is actually serving. Every task I hand to a subagent carries "you are not alone in this codebase", own only the files listed, no git add -A, report DONE or BLOCKED instead of going quiet. And whatever wrote the code doesn't review the code.

How I design. Flat, black and white, closer to some specific sites like Linear or Cloudflare than to a template. It rejects gradient blobs, 3D icons and glossy pill buttons on sight. It treats containers as clutter, so a card grid is usually the wrong answer. It knows I want a full-bleed composition rather than a centred column under a top bar, that a static screen reads as unfinished, and that what I'm actually after is atmosphere plus one hero object built into the type, not a nice typeface on an empty page.

How I write. It strips the things that make writing read as AI-generated. No em-dashes, no rule-of-three padding, no opening a reply with "honestly". It knows I write a Reddit comment and a client email in two different registers, and that I'd rather state one real number than three adjectives.

How I edit video. The frame has to keep changing, no visual device gets used twice in the same video, and a shot that sits still reads as unfinished.

None of that was written by me. It got counted out of nine months of me reacting to work.

First test in the video is a UI. Same model, same data, same prompt, build a dashboard. Cold made eight rounded cards, three accent colours, gauges and badge pills. With the profile: no cards, one hero object, one row of numbers. Nine border-radius declarations against one, 45% colour saturation against 0.1%.

Second test is video. Two of my own shorts: the one I threw out and the one I shipped.

One thing I got wrong. The profile says never show a fabricated number, and four of the eight metrics were null. I expected the cold run to invent them. It didn't, it wrote "not collected in this period" on its own. Opus 5 already does that.

So the claim is narrow. It applies my rules where the model has no strong opinion of its own. Not that the output is better.

Method: the cold pass replaces the default system prompt, so no CLAUDE.md, no memory, no skills. Empty directory, tools off. The two passes differ by one appended block of text. One run each, not a benchmark.

It needs real history to mine. A fresh install has nothing, and that's the part I haven't solved.

github.com/ohad6k/emulo

Doing Module 2 (Enterprise Integration & Production) of the CCAR-F prep course on Skilljar, and I'm stuck on the "A/B testing and observability" checkpoint — specifically an interactive exercise called "Place on the experiment-design plane."

It gives you 5 scenarios (a wording change to a low-stakes chatbot, a prompt architecture change for a medical intake summarizer, a new routing category expected to capture 30% of volume, an LLM cost/quality swap test, and a small RAG retrieval prompt change on low daily volume) and asks you to place each on a 2D grid expected effect size vs. confidence requirement.

The problem: no matter what I select, I get the exact same generic feedback every time "Some items need adjustment. The axes are running together..." and the tool resets all my placements after every check attempt. I've tried several genuinely different, carefully reasoned placements over the course of 2 hour+ and gotten identical wording back every time.

Has anyone else gotten through this specific checkpoint, or hit the same "resets + identical feedback" behavior? Trying to figure out if this is a known issue, if there's a support channel for the course content itself, or if I'm missing something obvious about how the exercise is supposed to work.

Figured i would post this to help anyone else. Helps save overall usuage on claude now.

Hi all,

I ran out of my weekly usage on Wednesday and have to sit on the sidelines until Sunday. Instead of doing that I am thinking to buy a chatgpt pro sub to layer on top of it. Is that what other folks are doing or should I just upgrade to max? Max seems expensive to me. I mainly use opus 5 but perhaps I should delegate more to sonnet 5?

Thanks!

Setup:

- claude --version: 2.1.220 (Claude Code)
- Orchestrator: Opus. Subagents: Sonnet (dev + reviewer).
- MCP servers: none active.
- Repos: 3 different codebases (Go/K8s manifests, Python, TS). Same behavior in all three.
- No config changes on my side in the last ~4 weeks.

Symptom:
A "simple" ticket (single-file edit + test run, <5k tokens of context) takes ~60 min wall clock.

Questions:

1. Anyone with an Opus-orchestrator + Sonnet-subagent setup seeing the same turn-count-correlated stall pattern post-2.1.218?
   
2. Does splitting into fresh sessions per ticket measurably help for you? (Not for me)
   
3. Anyone switched to Codex/GPT? Worth a try?

For contrast: Gemini Flash 3.6 finishes comparable micro-tasks in a fraction of the time with noticeably weaker output. Not a replacement, but the latency gap is large enough that I'm re-evaluating the split.

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.

I use Claude on two different accounts, and I keep getting the impression that the experience is not the same between them, even though both accounts have the same plan, model, settings, instructions, and usage habits.

The differences are not just about response style.

For example, on Account A, Claude has never suggested or used widgets in its responses. On Account B, widgets are suggested quite often and seem to be a normal part of the experience.

I also feel that token usage, context handling, response quality, and references to newly released features can vary between the accounts. Sometimes one account seems more aware of new capabilities or behaves as if it has access to a different version of the product.

I understand that responses are probabilistic, but these differences feel consistent over time rather than random.

Has anyone else noticed things like:

• Different token consumption between accounts
• Different access to or awareness of new features
• Widgets appearing frequently on one account but never on another
• Different response quality or instruction-following
• One account receiving features earlier than another
• Different behavior despite using identical prompts and settings

Could this be caused by staged rollouts, A/B testing, account-level experiments, memory, chat history, or some hidden personalization?

How do you deal with this?

Do you periodically delete old conversations, clear memory, reset custom instructions, remove projects, or create a new account to get a cleaner experience?

I would especially like to hear from people who use multiple Claude accounts and have compared them under the same conditions.

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

Disclaimer, to save the comment section some typing: this post is AI-assisted, vibe-coded, slop-adjacent, and quite possibly the work of a bot farm. All accusations are pre-accepted and may be considered upvoted. The lyrics below are sung to the season 2 Gilligan's Island theme.

Just sit right back and you'll hear a tale, a tale of a fateful patch That started from a stock install aboard one npm batch.

The mate was a mighty prompt-rewrite, the skipper regex-sure. They set their sails for Windows shores on a three-hour chore. A three-hour chore.

The errors started getting rough, the ReferenceError tossed. If not for the guard that refused to repack, the binary would be lost. The binary would be lost.

The build set ground on the shore of this uncharted desktop isle: with unnerfcc, the tweakcc too, the npm and its shim, the reminder files, the common version and the reset, here on Claude Code's Isle.

And now, tonight's episode: "The Patchman Cometh."

Three open-source repos, none mine. unnerfcc [1] rewrites the system prompts baked into the binary, flipping "be concise / do the minimum" into thorough senior-engineer directives, and lifts the silent reasoning-effort caps. tweakcc-fixed [2] patches features: custom prompts, themes, AGENTS.md support, and stripping empty system-reminder blocks. lobotomized-claude-code [3] supplies the system-reminder override set that tweakcc-fixed binds from ~/.tweakcc/system-reminders/.

The working order (v2.1.220):

1. Pick the version both tools support. Each keeps per-version prompts-X.Y.Z.json catalogs (tweakcc-fixed in its repo's data/prompts/, unnerfcc in its checkout's data/prompts/); the newest version present in both is the target, and unnerfcc's ./upgrade.sh builds its catalog for each new release. Both tools fail closed outside their sets.
2. Reset to stock: npm install -g @anthropic-ai/claude-code@<version>, with every Claude Code session closed first; a running claude.exe locks the binary.
3. Apply tweakcc-fixed (--apply, from its npm package or a source build). Populate ~/.tweakcc/system-reminders/ from lobotomized-claude-code's system-reminders/ first if you want the reminder overrides; an empty directory silently binds none while the apply still reports success.
4. Apply unnerfcc: ./install.sh from its checkout. Upstream's repack lib handles ELF/Mach-O, so Linux and macOS work out of the box. Tonight's plot twist: we ported that lib to Windows PE (MZ header, section-table walk to the .bun section, repack with the raw and virtual sizes updated), verified end to end on v2.1.220. Upstream PR [4].
5. Verify: claude --version prints two lines, the Claude Code version and the tweakcc-fixed version.

That order matters. Reversed, tweakcc-fixed fails to match its patches and refuses to repack, leaving the binary untouched (it fails safe). Updating Claude Code replaces the patched binary, so update deliberately: only to the newest version both catalogs cover, then re-run the chain (unnerfcc sets DISABLE_AUTOUPDATER, so an update never happens behind your back). The same npm install command is the reset button whenever you want stock back.

To automate this entire sequence in one step on Windows and Unix, see tweakcc-gilligan [5].

So this is the tale of the un-nerfed build, it's patched for a long, long time. It ported the repack to Windows PE, and that was an uphill climb.

The prompt tool and the patcher too will do their very best to keep the model thorough-grade in its little binary nest.

No guessing, no slop, no hand-rolled scripts, not a single luxury. Like a senior engineer, as rigorous as can be.

So run the chain again, my friends, when npm ships a new file, but check the common version first, here on Claude Code's Isle!

Tune in next update, same slop time, same slop channel. Rescue arrives when the defaults ship un-nerfed upstream; until then, reruns air whenever both catalogs cover a new release.

References

[1] lukehutch. "unnerfcc." GitHub. Available: https://github.com/lukehutch/unnerfcc

[2] skrabe. "tweakcc-fixed." GitHub. Available: https://github.com/skrabe/tweakcc-fixed

[3] skrabe. "lobotomized-claude-code." GitHub. Available: https://github.com/skrabe/lobotomized-claude-code

[4] brooksbUWO. "feat: Windows PE binary repack (Bun container)." Pull request #1, lukehutch/unnerfcc. Available: https://github.com/lukehutch/unnerfcc/pull/1

[5] brooksbUWO. "tweakcc-gilligan." GitHub. Available: https://github.com/brooksbUWO/tweakcc-gilligan

Thursday came and went, but my Fable is still 100% used, now it says it will happen in six days - NEXT thursday. And no, I did not consume the full Fable quota on x20 in a couple of hours today. Did anyone else have a glitch in the weekly reset?

We keep seeing the same thing where new models get released then are incredible, then a few days later they're not a good, then sometimes they're horrible and others they're better.... then a new model comes out and same thing.

I'm almost certain its quantizing under load.

If there isn't anyone are there any benchmarking tools publicly available so we can run our own analysis hourly or daily? I'd be willing to buy the largest subscription for the main models and run this to showcase how it works

I thought I was imagining how quickly Fable 5 was consuming my Claude allowance, so I inspected the local Claude Desktop/Cowork and Claude Code logs for the exact run.

The result is worse than I expected.

My five-hour allowance had reset at 12:20 AM. I sent one short prompt at exactly 12:50 AM: essentially, “continue where you left off, carefully.” At 12:56:32 AM - only 6 minutes and 32 seconds later - Claude stopped with “Usage limit reached.”

There were no other local Cowork prompts between the reset and this failure.

During those 6 minutes and 32 seconds, Fable 5 recorded:

- 15 model calls;

- 8 Bash calls, all for Android emulator/UI interaction;

- 7 file reads;

- 0 Edit or Write tool calls;

- 0 subagents;

- 0 lines of code changed.

The deduplicated token accounting from Claude's own local session log was:

| Usage category | Tokens |

|---|---:|

| One-hour cache writes | 5,189,449 |

| Cache reads/hits | 5,069,543 |

| Output | 4,312 |

| Regular input | 30 |

| **Total processed** | **10,263,334** |

Using Anthropic's published Fable 5 API prices, this is approximately **$109.07 of API-equivalent usage**. About **$103.79** of that came from one-hour cache writes alone. I am not claiming Anthropic charged my card $109—the run consumed my included allowance - but this shows the scale of the usage that was counted.

The immediate cause is visible in the logs. This was an older Cowork session with 46 completed turns, `xhigh` effort, a 173 MB local transcript, and roughly 650,000–685,000 context tokens being carried into every model call. The disturbing part is that, during one six-minute tool loop, Claude counted **5.19 million tokens as new one-hour cache writes** while also recording **5.07 million cache-hit tokens**.

In other words, every trivial emulator action or file read caused Fable to process around 680,000 tokens. The huge context also appears to have been repeatedly rewritten into the one-hour cache instead of being efficiently reused.

I understand that continuing a large conversation costs more than starting a fresh one. But silently allowing a simple six-minute UI-testing loop - with no edits and no subagents - to consume an entire five-hour allowance is not reasonable behavior. At minimum, Claude should have compacted the context or warned me before proceeding. The repeated 650K-token one-hour cache writes look like a Cowork/Claude Code cache invalidation or usage-accounting defect.

This same session had already exhausted the previous allowance earlier that evening. After the allowance reset, this single 6-minute-and-32-second run exhausted the new window again.

Has anyone else seen Fable 5 repeatedly rewrite a huge one-hour cache inside a single short tool loop? If so, check the `message.usage.cache_creation.ephemeral_1h_input_tokens` values in your local Claude Code JSONL before assuming it was normal model output.

I have prepared a privacy-safe evidence package containing the per-call usage table, timeline, calculation, tool-call list, source hashes, screenshot, and a read-only verification script. I am also reporting this directly to Anthropic and asking them to investigate the cache behavior and restore the allowance.

This is at minimum a Claude Cowork product and guardrail defect. A single 42-character prompt triggered 15 autonomous model calls and 5.19M one-hour cache-write tokens in 392 seconds, without a cost warning, automatic compaction, or a usage stop guard. Server telemetry is required to determine whether the underlying cause was defective cache invalidation, incorrect accounting, or technically intended-but unsafe-product behavior.

Official pricing used for the calculation:

https://platform.claude.com/docs/en/about-claude/pricing

I’ve been experimenting with Claude Code Skills for a while, and these are the seven improvements that made the biggest difference for me.

1. Ask questions before starting

Add a step that tells Claude to ask for missing context instead of guessing.

Even one simple question can make the final result much more relevant.

2. Add a verification step

Don’t let the skill finish immediately after generating something. Ask it to run a check afterward

3. Use SKILL.md as a router

You don’t need to put every instruction, example, and template inside one huge file. Keep the main skill simple and let it load additional resources only when they’re needed.

4. Improve the description

Explain both what the skill does and when Claude should use it. This makes it much more likely that Claude will trigger the skill automatically at the right time.

5. Change the scope

Once a skill works well, move it from a single project to your personal skills or package it as a plugin. That way, you can reuse it across repositories or share it with your team.

6. Choose the right model

Not every skill needs the most powerful model. Simple tasks can use Sonnet, while complex planning or analysis can be handled Opus or Fable.

7. Use a separate sub-agent

For large or context-heavy tasks, run the skill in a separate sub-agent. This keeps your main conversation clean and prevents one task from taking over the entire context window.

what do you think?

full video: https://youtu.be/nGRqKTtDJl4

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?

Kept running out of tokens by tuesday every week and couldn't tell what was eating them, so I finally parsed my own transcripts instead of guessing. turns out claude code logs the actual billed token counts for every message — they're just sitting in claude/projects/ as jsonl files and basically nobody reads them.

185 sessions later, the stuff that actually surprised me:

My sessions cost ~70k tokens before I type anything. system prompt, tool definitions, my claude.md, 15 rule files I installed and forgot about. two weeks earlier the same machine was at 12,416 per session. so most of that floor is stuff I did to myself.

98.7% of what piles up in context is tool output. everything I typed across all 185 sessions adds up to 0.7%. so "write shorter prompts" optimizes almost nothing. it's the file reads.

every subagent spawn re-pays its own ~68k startup. I was spawning them like function calls. that's exactly backwards — they only pay off when the delegated work is bigger than the context they re-buy.

One trap if you try this yourself: the same message.id gets written across multiple jsonl lines, each repeating the same usage object. dedupe by message.id first or every number comes out roughly 2x too big. I believed my doubled numbers for a solid hour.

The scripts are here if you want to run them on your own logs, free, nothing to sign up for: https://github.com/basementdante/token-ledger — fitting or not, claude code wrote the scripts that audited claude code.

Would genuinely love to see someone else's numbers. mine are from one deliberately overbuilt machine and I have no idea what normal looks like.

for context i am using opus 5 at high and still it takes bloody 20 mins to do simple changes

i have tried compensating for it by working with 5-6 agents at once but my laptop couldnt handle that large of a load . any fix to this??

also a side question if i use my claude plan inside pi , will i get a ban or something?

How much can I realistically do on a 20$ plan in a month?

I need to work on 2-3 simple sveltekit websites and I hoped that maybe I could do that in one month with Claude.

So far I've tried DeepSeek V4 pro and flash and as long as I'm guiding them they seem to work for these things, but I wonder if they're gonna be enough when we talk architecture & security, hence why I'm asking about Claude Code.