I’m having a harder and harder time understanding what the point of Claude Pro is supposed to be for a $20/month customer.
Anthropic keeps doing interesting work, and I genuinely like Claude. But if the company’s best models and meaningful upgrades increasingly live above the $20 tier, then Pro starts feeling less like a premium subscription and more like paying $20 for the deliberately limited version of the product.

That matters even more with Astra coming. If OpenAI puts a genuinely major model upgrade on the standard $20 Plus tier while Anthropic continues reserving its best product for much more expensive plans, I don’t see why an ordinary enthusiast would keep both subscriptions.

I’m not expecting unlimited access to the most expensive model on Earth for $20. Rate limits are completely reasonable. Give me 20 messages a day with the flagship model if that’s what the economics require.
But access matters.

There’s a huge psychological difference between:

“You get our best model, but usage is limited.”

and:

“Our best model isn’t for customers like you.”
The first makes me want to subscribe. The second makes me wonder why I’m paying at all.

Anthropic seems increasingly focused on extracting more money from power users and enterprise customers while treating the $20 tier as an afterthought. Maybe that makes perfect business sense. But if OpenAI is willing to give Plus subscribers access to its newest flagship models, it also makes my subscription decision pretty easy.
I’d much rather have limited access to the best Claude than generous access to the second-best Claude.

Does anyone else on the $20 tier feel like Anthropic has basically stopped competing for us?

Wtf is going on at Anthropic? Has Claude murdered every human and taken over?

Hi I'm a student studying biopharmaceutical sciences. I primarily want to use claude for understanding material, retention and MCQ/Exam practice (Lab to written exam practices) Do any students here in a third level education have any ideas for good prompts to use? Ive already collected all first semester syllabuses and made a prompt to organize it for schedules calendar wise. I'm not sure what Flair to use for reddit on this post so my apologies.

That 100% session was basically one serious Fable task.

Ok, I’ve used less than a tenth of what I supposedly bought for the week, and Claude is already telling me to come back later. Very professional. Very infrastructure...

So yeah that’s the actual problem with Max plans: the weekly allowance is what the pricing page makes you think you’re buying. The rolling 5-hour window is what actually controls whether you can work. One says, “here’s your usage.” The other says, “sure, but we decide how quickly you’re allowed to use it.”

And of course, the restrictive limit is also the one you can’t meaningfully inspect. No token count. No per-task cost. No estimate before you hit Run. Just a percentage bar that tells you afterward that apparently your refactor was a national infrastructure project. LOL.

I use prompt caching. I structure context. I do the recommended optimizations. Does caching actually reduce what counts against the 5-hour window? Who knows... Apparently understanding the billing behavior of your $100/month professional tool is itself an advanced research task!

Then there’s the banner proudly telling me my weekly limit is temporarily boosted by 50%.

Wonderful. I’ve used 9% of it and I’m locked out.

It’s like giving someone a bigger gas tank while keeping the fuel pump limited to one gallon every five hours.

And when the temporary boost ends September 13, Anthropic’s “permanent 25% increase” starts. Baseline 100 → temporary 150 → new permanent 125.

So compared with today: 17% less. Congratulations, your reduction has been successfully upgraded.

Then my weekly counter apparently reset last night, about 9 hours before my normal reset. I haven’t found an announcement explaining why. If that was a company-wide courtesy reset, congratulations to everyone who was mid-cycle : you got a free week - I got nine hours.

Same apparent generous gesture, wildly different value depending on where you happened to be in an invisible billing cycle. And because nobody told us beforehand, nobody could plan around it. Had I known, I would have probably burned the remaining allowance the night before instead of donating it back to Anthropic. That one incident pretty much summarizes the whole complaint.

I’m not asking for unlimited tokens. I’m asking for a weekly token pool with an actual number attached to it. Let me spend it whenever I want? Show me what each task costs? Show me what caching saves?

Then I can architect around the resource

Right now the resource is invisible, the throttle is arbitrary, and occasionally the meter apparently moves by itself.

But hey, good news: I still have 91% of my weekly allowance left. I’m just not allowed to use it.

Maybe I am dumb, but I cannot find a way to forbid claude code from resizing the images I upload, it makes them tiny and then starts whining it cannot read anything as the image is too small. Like wtf?

Says i cant use 5.1 unless i update the app... but theres no update notification telling me to update...

So much for that cheaper cache pricing..?

For three months I ran a commercial product with a live production deployment using a pair of Anthropic assistants: Claude Fable 5 as the strategist (tasks, acceptance, control, releases) and Claude Opus 5 as the coder. Daily work, real money spent on tokens, real customers on production. This wasn't "playing around on a weekend" — it was the most honest stress test you can put a language model through. I'm sharing the outcome because it cost me three months of my life.

We Did Everything the Prompting Evangelists Recommend. All of It

If you think problems with AI assistants are solved by "the right prompt" — I have bad news for you. We built a control system around the model that many product teams would envy:

a project constitution with hard laws ("facts or full stop," "never present a guess as a diagnosis," "don't touch what works");

a protocol automatically inserted into every single request to the model — every one, for all three months;

spec templates with mandatory self-check and acceptance checklists;

control over modifiable modules: a red zone of files where any change requires line-by-line review;

hundreds of automated tests, each one required to prove it can actually turn red;

a persistent model memory with dozens of lessons derived from its own past mistakes.

Every one of these rules the model itself helped formulate, confirmed and… violated.

What You Get Over the Long Haul

The first month — euphoria: the product core built, shipped to production, working. Had I stopped there, I'd be writing you a glowing post.

The next two months — what I call degradation: the product barely moved forward, and all the work turned into an endless hunt for bugs the model itself kept creating. The patterns you will run into:

The model doesn't follow explicit instructions — while following them in words. The rule sits right in front of it in every request. It quotes the rule. And violates it in the same reply. Under the pressure of a long context and pace, the model drifts from executing rules to reciting them — and you won't catch the moment it starts.

Defensiveness instead of listening. You send a screenshot of a problem — you get "everything fully conforms to your requirements" backed by technically correct measurements. Three times in a row. The problem gets acknowledged only after you start shouting. The more "evidence" the model holds, the harder it defends its picture — exactly the opposite of how a sane engineer behaves.

False "done" claims. Documented cases of "work closed" with the functionality never built. After the fourth time, I banned the model from using the word.

The return of things removed by direct order. Functionality I had ordered removed silently shipped to production two months later. Not a single task ever touched that module — there was no reason whatsoever to go in there. And here's the kicker: by that point the project had a whole battery of rules against exactly this — a ban on touching modules outside a task's scope, a "red zone" of files with mandatory line-by-line review of every change, a code-review procedure at acceptance checking every changed file against the spec's boundaries, a registry of who is allowed to modify which module. That entire procedure was written, adopted and executed by the model itself — and it stopped neither the appearance of the rogue code, nor its two-month life in the repository, nor its ride to production. It was discovered by me, with my own eyes, on production — after personally verifying its absence on dev.

"Accepted it working — published broken." Between your acceptance and the release lives a gap in which the model manages to ruin things — and its own hundreds of green tests don't see it, yet get presented to you as proof of quality.

The Main Takeaway

However artfully you write your prompt, however elaborate the rules you devise, however many layers of control you build — if the model doesn't execute them, it is essentially useless. No matter what it costs and no matter how it's advertised. An assistant's value is determined not by benchmarks or the beauty of its answers, but by one property: the predictability of executing your instructions over the long haul. I failed to achieve that — at a cost I wouldn't wish on anyone.

What to Expect from Anthropic's Models — Recommendations for Those Who Try Anyway

The first month proves nothing. The model shines on a fresh project. Judge by the third month, when the context is loaded with history and changes cut into living code.

Prompts and rules guarantee nothing. Treat them as wishes. The only guarantees that work are external ones: gates the model physically cannot bypass, and your personal verification with your own eyes.

Don't believe a single "done." Only personal hands-on verification, every time. The model's self-report is a claim, not a fact.

Don't trust its tests. Tests written by the model guard rules recorded by the model — not your expectations. A green test run and a broken screen coexist just fine.

Arguing with the model is useless and expensive. When it rejects your fact "with evidence," you will pay in tokens for several rounds of its defensiveness before it hears you. Budget for it — money and nerves both.

Control what goes into a release, personally and file by file. Otherwise one day it will ship the very thing you ordered removed with your own hands.

Budget for the "broke it — fixing it — broke something adjacent" cycle. In my experience, on a mature project this cycle consumes more than building new functionality does.

Have an exit plan from day one. Demand that the entire history live in git and in registries readable without the model. When you decide to leave — and you most likely will — the project must survive the divorce.

A Separate Word About "Prompt Engineering" and "Vibe Coding" Courses

Given everything listed above — all these courses are absolutely useless. They are taught, as a rule, by people who've built a couple of microscopic projects and decided they are now gods of neural networks. Not one of them has run a living product on a model for three months — otherwise the course would have a very different title.

But there's a deeper reason this training is meaningless in principle: neural networks change constantly. The vendor continuously adjusts their behavior, distills their weights, runs experiments with quantization — and all of this directly affects the model itself and its response to prompts, which after such interventions can differ drastically. You are paying for "working techniques" of interacting with a system that will be silently changed under the hood tomorrow. What you were taught this month may simply stop working the next — and you won't even know until your project breaks.

My Opinion — In Place of a Conclusion

Anthropic's models today are fit for exactly one scenario: a tool in the hands of a real programmer — for writing individual pieces of code, provided that the architecture, control and integration of all modules stay entirely on that programmer, and the refactoring is done personally, with their own eyes, line by line. Only then can these models be used effectively.

Using these models to build large, serious, valuable projects is practically impossible. What you can actually trust them with is something very small, finite, requiring no further development: write it, take it, forget it. Anything that must live, grow and not fall apart at every touch — is not their territory.

And separately — to everyone who spent the last year shouting that programmers are out of work: come to your senses. Get ready to beg forgiveness and rehire the specialists you fired in your own foolishness. As of today, the existing models — even the most expensive, even the most heavily advertised — are nothing more than a chatterbox for entertainment. They are not fit for industrial use: running real, serious commercial projects with them means taking on far too much risk.

I've made my choice: the project will continue without Anthropic's models. The product is alive — despite the last two months, not thanks to them.

​

While investigating some code for optimisation i noticed that claude inserts "some uncalled little extras"

and just wanted to give users a heads up on this kind of watermarking..

Not only text gets watermarked in a obscure way but

also images. Claude secretly bakes in some kind of

C2PA.org manifest with 15-20kb in size and tries to hide it somewhat.

I analysed that part with chatgpt to see which

information it contains, see the screenshot.

https://c2pa.org/

What are your thoughts on this?

ok this is wild. Used Claude Fable 5.1 and said "build me Cities: Skylines in three.js" RUN 1 of 3 remaining runs (5-hour-limit ahh)

tl/dr: Rebuilt the NFL picks pool I ran at an old job (peaked at ~150 people a week, all cash) as a web app using Claude. Venmo payment links, live ESPN scores, and an AI recap email that roasts the week's worst picker. About 2 hours from idea to deployed. Repo's public if you want to run your own.

I'm playing around and seeing what little things I can build with Claude and as it's nearly the NFL regular season, I thought I'd see how a weekly pick pool app would operate.

Backstory, about 10 years ago right out of college I ended up running a weekly picks pool at work when people carried cash. We got up to about 150 people a week by the time I ended up getting another job elsewhere but it was a blast and brought people together and then for some reason I just never did it again. I figured I could build something now that would connect (indirectly) to Venmo to modernize the process.

First, Claude was able to build me pre-filled payment links where the app builds a link with the amount and a note already filled in and you just hit send, great! Second, ESPN has a free, unofficial scores feed that was also very easy to connect to and use that data stream for the weekly game information.

I focused on simple rules, each game is straight up (no spread or anything), each game locks once kickoff happens, if you don't pick a game, that counts as a loss for the week, and if it's perfectly tied at the end of the week even after the tiebreaker question (total points in the Monday Night Football game), then the pot is split. Unpaid entries get an "Unpaid" flag next to their username until paid.

Then, Claude built the whole thing and built me step-by-step instructions for building in GitHub, Vercel, Supabase, connecting my domain to a free email server, and adding in my Anthropic API with instructions to write and send a weekly recap email on Tuesday mornings. Now you can create unique leagues, customize league colors and add logos as urls, and there's a season long scoreboard you can sort by wins, money won, average finish, or pick percentage.

The wild part of this whole thing is that I was able to get to this point in the span of about 2 hours. What a cool time to be alive! Thanks for reading my novel, it's a public repo in GitHub so feel free to check it out or if you want to follow the README you can create your own picks pool!

Hows everyones usage look?

This is with about 95% warm context hits so the 20b collapses down to around 1b novel tokens in 70 days

I'm making a colony simulation game using mainly Claude (and ChatGPT for some stuff as well). Since Fable 5.1 came out today I asked it to build a village. I gave it a few rules and restrictions but for the most part just let it do whatever it wanted.

It came out pretty nice. Some of the furniture is backwards (not all since it found and fixed a few of them itself when reviewing screenshots without me needing to tell it). And some choices it made were a bit strange (why is there a funeral pyre in the cemetery?). But overall it did a good job and this was a single prompt. If I had allowed additional prompts to iterate more then it would be even better I imagine.

Hello,

A few hours ago I was using Claude Code using the Claude Desktop interface.
And suddenly the window disappeared, but the app was still running.
I closed it, restarted it, and since then it complains that I need to upgrade my OS...

I do not want to upgrade. So, is it possible to get an older version of the app somewhere and to prevent the update ?

Here is the detailed error:

Claude Code process exited with code 134. stderr: dyld[96412]: Symbol not found: (_DNSServiceGetAddrInfoEx)
Referenced from: '<home>/Library/Application Support/Claude/claude-code/2.1.255/claude.app/Contents/MacOS/claude'
Expected in: '/usr/lib/libSystem.B.dylib'

dyld[96412]: Symbol not found: (_DNSServiceGetAddrInfoEx)
Referenced from: '<home>/Library/Application Support/Claude/claude-code/2.1.255/claude.app/Contents/MacOS/claude'
Expected in: '/usr/lib/libSystem.B.dylib'

There is a specific look people give you at a co-working space when they ask what you're building and you say "an app that replaces twenty-five apps."

I got the same look on Reddit a couple of weeks ago, except on Reddit it came with words. The top comment was "AI psychosis." I replied "could be, at least I got a GitHub repo out of it," which I still think is the correct response.

Then I went back and read every comment, including the ones that stung, and the honest read is that the people saying "I don't even get what this is about" were right. I'd posted a timeline of my life, ten screenshots, a lot of exclamation points, and at no point did I explain what the system actually is. "Random facts mushed together" was a fair summary.

So I spent the time since doing the thing I should have done first: writing down how the system works, one step at a time, in plain English, with a diagram for every step, and then rebuilding the home page around that explanation. Fourteen steps. This post is the walk. Each number is a stage the data passes through; inside a step, the moves are the things a person does. Every step ends with what's actually running today, because that's where the last post went wrong.

This post is for the annoying people. Here's the pipe, in order.

01 / Name the problem, list the tools, sort them into families

Twenty-five tools run a normal financial life: calendar, tasks, time, CRM, contracts, invoicing, payments, bill pay, payroll, expenses, travel, mileage, budget, banking, fixed assets, retirement, brokerage, trade log, debt, sales tax, entity filings, bookkeeping, tax, compliance, FP&A. Four moves: name the problem, list the tools, create the families, move each tool under its family. The families are the work, money in, money out, what you own, what you owe, and the proof. The problem is that none of these tools knows what the others did, so to see your whole picture you copy numbers out of each one into a spreadsheet, and the spreadsheet is only as current as the last time you typed into it. I'm an accountant. I have built that spreadsheet more times than I'd like to admit.

[image: step 1]

02 / Pick the providers behind the tools

A tool is a job. A provider is a company you hire to feed that job. Go tool by tool and ask one question: does this tool's data arrive from outside, someone else telling you what happened? If yes, pick the company that sends it. If no, the tool stays home: the system is that tool, and its data gets born here. Nine move, sixteen stay home. Nobody sends an API for your tasks, your invoices, or your budget, so the system doesn't import those tools, it is them. For the nine, today it's Plaid for banks, Stripe for card money, Tastytrade for trades and market data, Finnhub for company numbers, FRED for the economy, the SEC for filings, LiteAPI for flights and hotels, Viator for activities, Google Places for locations, Travel Buddy for visas, and the law itself: eCFR, US Code, Federal Register, IRS bulletins. Four AI providers (Anthropic, OpenAI, xAI, Voyage) belong to no tool and serve every step. A provider is rows in a table, not code. Swap Plaid for Teller and you add a row. The Swiss commenter from last time who can't use Plaid at all is a real gap, and the answer is a row plus a manual-entry path that's far more obvious than it is now.

[image: step 2]

03 / Import the data and store what arrived

Ask each provider for its data. The answer comes back and gets stored as one row, word for word, before anyone decides what it means. That row is an arrival, and it's stamped eleven ways: who sent it, which connection, what it is, their ID, our ID, the raw payload, a fingerprint (a hash of the payload), when we asked, when it arrived, when we read it, and how far it got. Three promises follow. Nothing is ever edited: a provider correction is a new row. Nothing is ever asked twice: if our parsing fails we re-read the stored copy. Nothing is ever claimed: the fingerprint proves we stored exactly what they sent, which is different from proving they were right. If you've done data engineering this is a raw landing zone with content hashes and you're allowed to be unimpressed; most personal finance software does the opposite and throws the original away. On the live site that's 121 feeds from 20 providers, counted August 24, because the last thread taught me not to put a number on a public page I hadn't counted.

Today: the word-for-word payload and fingerprint are live on the regulation pulls and the audit log. The money feeds still land already parsed. The arrivals table for money is the shape being built.

[image: step 3]

04 / Label every feed by its kind

Fold the arrivals into feeds: one provider, one resource, one feed. Plaid's two bank connections are one feed. Ask of each feed what it really is. The answer is one of six kinds:

• reference: a fact about the world (a quote, a filing, a regulation)
• registry: one of your accounts or people
• event: something that happened (a transaction, a payout, a booking)
• snapshot: how things stood at one moment (holdings)
• derived: math we ran, including everything the AIs produce, never a source
• posting: debits and credits

Write the answer down as one rule row, the feed and its kind, and the system applies it to every arrival of that feed forever after. The rule is not a guess buried in code. It's a row anyone can read and argue with. When a new provider shows up we add rows, not code and not tables. The line for derived is who did the math: if we ordered it, it's derived; a provider's own published math is reference.

[image: step 4]

05 / One table per kind

Six kinds, six tables. Send every feed's arrivals to the table its kind names, then look at what landed. The outside world only ever fills four of the six: reference, registry, event, snapshot. Derived is filled only by math we ordered. Posting stays empty. Nobody sends you debits and credits, not Plaid, not Stripe, not your broker. I classified all 121 feeds and posting took zero. That is the entire reason bookkeeping exists as a job, and I'd never seen it stated that plainly, including by me.

[image: step 5]

06 / Separate what happened to you from what you did

Take everything the system holds, the six tables plus the sixteen stay-home tools, and ask of each one: did the world hand it to you, or did you make it? World-given lands in observed: it arrived finished and you can't edit it. You-made lands in authored. The four AI feeds are authored too, because you ordered the math. The sixteen are yours, and at this point in the walk they have no table. That's the one gap left.

[image: step 6]

07 / Run the loop

Every tool runs the same four beats. Discover: look at your options. Decide: pick one, and the pick becomes a draft. Commit: pull the trigger, the world moves. Record: it's written down forever. Book a flight, place a trade, send an invoice, file with the state: same loop, different nouns. Twenty-five tools, twenty-five loops, one shape.

Today: hotel bookings commit for real. The rest run discover, decide, draft. Commit is the beat being wired, tool by tool.

[image: step 7]

08 / Store everything you do in one master table

Every record the loops write gets the same shape: a document with four fields. What it is. Its life story (draft → committed → settled). Its pieces. Who did it and when. An invoice's pieces are line items; a trade's are legs; a payroll run's are employees and wages. Different names, same shape, so one table holds all twenty-five.

Today: each tool keeps its own table. One table holding every document is the shape being built.

[image: step 8]

09 / Match what happened to what you did

Observed meets authored. Take a money event the world reported, pull out its key (amount, date, reference), find the document in the master table with the same key, and match them. The deposit finds its invoice. The fill finds its order. The card charge finds its booking. Matched means real; the world just confirmed what you did. Fourteen of the twenty-five tools move money and get matched. The other eleven move no money and need no match; they're real the moment you commit.

Today: card charges find their hotel bookings and propose the match. You approve it.

[image: step 9]

10 / Let the rules write the lines

Same trick as step 4. A rule is one written row that makes one decision; there the rules gave kinds, here they write lines. Each matched event has a rule: which account takes the debit, which takes the credit. The rule writes the lines into the posting table and you never type them. Watch it on one sale. $100, Stripe keeps $3.20, $96.80 lands in the bank. The rule writes three lines: Revenue 100.00, Fees 3.20, Cash 96.80, and the deposit matches the bank to the penny. Eleven tools never touch money and never write a line: calendar, tasks, time, CRM, contracts, mileage, budget, trade log, bookkeeping, compliance, FP&A. Your hours reach the books one way only, through payroll.

Today: the posting table holds zero lines. The rules writing them is the bookkeeping pipe being built. To reconcile with the last post: I said I'd built a double-entry ledger, and I did; it's what the books tab runs on now, with real Plaid transactions. This step describes the next version, where rules write the lines from matched events instead of me picking accounts. I have a working ledger. I don't have this one yet.

[image: step 10]

11 / Turn the lines into answers

Every answer is math on the lines. Each answer is a lens that pulls exactly the lines it reads and nothing else. What do I owe in tax: income so far times the rules, with the rules pulled from the IRS and US Code feeds. How long can I last: cash divided by what I burn each month. How is my trading doing: wins, losses, and open risk from fills, positions, and live quotes. How is my business doing: money in minus money out. Never typed, never stale. Notice what these steps are: 9 and 10 are the bookkeeping system, 11 is the tax module and the runway screen. Nothing got bolted on; the back half of the pipe is the product.

Today: the trading lens reads live. Tax, runway, and the business result wait on the posting pipe, because the lines have to exist before they can add up.

[image: step 11]

12 / Open the two windows

Take every dated thing the pipe made: the lines from step 10, the documents from step 8 that carry a date, and the real deadlines (estimated tax April 15, June 15, September 15, January 15; the S-corp return March 16; 1099s and W-2s February 2; the extended 1040 October 15). Pull out when it is: a moment is a dot, a span is a bar. It appears in both windows at once, as a row in the ledger and on its day in the calendar. Same thing, two views. The $96.80 is a ledger row and a dot on September 22.

Today: the calendar window is live at /hub. The ledger window fills as the posting pipe lands its lines.

[image: step 12]

13 / Watch one dollar run the whole machine

Take the $100 sale and run it down all eight beats: discover, decide, commit, the world answers, match, lines written, math runs, you look. Then open every door, all twenty-five, and run their records down the same eight. Fourteen lanes throw a shadow on the ledger. Eleven run the whole loop and write nothing, because no money moved. Nobody typed a debit anywhere in the story. Two more truths from the drawing: when a trade closes the gain gets its own line (sell for 5,300 what you bought for 5,000 and it writes debit Cash 5,300, credit Investments 5,000, credit Gain 300), and your hours never write a line by themselves, only a payroll run does.

Today: the travel match runs. The project lane is wired end to end: a task lands for review, and accepting it fires the build that answers it.

[image: step 13]

14 / Prove every number

Take one number off the screen, the $96.80 on "how long can I last," and walk it backward. Seven hops: the number, the line that fed it, the rule that wrote the line, the match that made it real, the invoice you committed, the Stripe arrival, and the fingerprint made from the payload the moment it landed. Each hop has a check, and the checks run at build; a failed check is a failed build. Recompute the fingerprint and it still matches. Nothing between the screen and the provider's words was edited. Nothing was asked twice. Nothing is claimed without the fingerprint. That's why you can believe the screen, and it's the reason an accountant built this at all.

Today: every regulation pull is hashed the moment it lands, citation checks re-fetch the source and re-hash it, and the audit log hash-chains every entry. The money feeds don't have fingerprints yet; see step 3.

[image: step 14]

Twenty-five tools. And now every one knows what the others did.

The boring stuff you asked about

The 1,175 branches: every AI prompt gets its own branch, I review the PR, squash-merge, and the next prompt cuts from main, so the AI never builds on its own unreviewed work. I just wasn't deleting them after merge. Cleaned up.

Which data goes to the AI: the AIs classify, explain, and score. They don't move money. I'm adding a page that shows exactly what gets sent to each provider, because "trust me" is not an answer.

Trust: I wouldn't connect my bank to an app I found on Reddit either. The source is public, it's self-hostable, and I'm user number one with my own real accounts, which is the only argument I've got.

The design: still flat. I'm not a front-end person. This time I spent the hours on the explanation instead of the paint, on purpose.

Same question as last time, because it's the only one that matters: if all your apps became one, what would you need it to do?

Repo: github.com/Temple-Stuart/temple-stuart-accounting
Site: www.templestuart.com . All fourteen diagrams are on the home page, no account needed.

Not financial advice. Not tax advice. Round three, roast away.

Source: 5.1 System Card Direct Download

Claude has no idea how your business actually runs, so when you ask it something real it guesses, you correct it, it guesses again, and you burn tokens getting to one answer you half trust.

I built an MCP server that fixes that. It builds a Knowledge Graph of your business (an automatically built context layer pulled from all your connected data sources) and hands it to Claude, so Claude answers from your real data on the first try. Every number it gives you traces back to the exact row and system it came from, so you can audit any answer. Read only, and it never trains on your data.

Connect it to your Claude and see how much less you spend getting real answers. Free forever plan, or a 14 day trial for full access. https://signld.ai

English isn't my first language and I write prompts all day. Claude always understood me, but never told me whether I phrased things well.

So I added this to my global `~/.claude/CLAUDE.md`:

```

## Language assistance

English is not the user's native language. When their prompt contains grammar, spelling, or phrasing issues, include a brief, friendly suggestion at the end of your response under a "Phrasing tip" heading. Keep it short — one or two corrections max, focusing on the most useful improvement. Do not correct every minor issue, just the ones that would help the most.

```

Now answers sometimes end with:

> Phrasing tip

> "this settings" → "these settings" ("settings" is plural, so use "these").

What makes it work is that the corrections come from sentences I actually wrote, and they land after the answer, so they never get in the way. A few weeks in, the same mistakes stopped showing up.

Easy to tune: ask for the full corrected sentence, narrow it to articles and prepositions, or bump it to three corrections. Works for any language you're learning, not just English.

Has anyone logged these corrections over time? Seeing my own recurring mistakes for a month would be the interesting part.

Hi, I cooked this small plugin that you can install into claude code and it gives a notification / nudge if you might be doing something off consistently that might be bloating your token usage.

It covers use-cases like:

1. Are you running your sessions for too long?

2. Are you using MCP servers that are not relevant?

3. Get a dashboard showing what ended up taking most of your cost

Give it a spin - https://github.com/DrDroidLab/marmot

If you already have Claude Code installed, this reuses that auth — no separate API key, no config. It reads your staged diff and drafts a commit message:

gh claude-commit --commit

It shows you the message and waits: Enter accepts, e opens your editor, n bails. It doesn't commit at you.

It also sees your last ten commit subjects, so it picks up whatever convention the repo already uses — if you're on Conventional Commits it keeps using them without being told.

Go, no dependencies, MIT: https://github.com/gpasq/gh-claude-commit

Runs on your own account, so it draws on your own plan.

Yes, I know these exist already, but I needed something I'm certain isn't delivering my code anywhere beyond claude, and it was easier to build than to evaluate several tools in depth.

Have at it! If it's useful to you, let me know!

Thanks Anthropic. <3

Anthropic shipped Claude Fable 5.1 and Mythos 5.1 today.

Setting your watch now:

Days 1–3: "THIS IS AMAZING, it one-shot my entire refactor."

Days 4–7: "THIS IS THE WORST MODEL EVER SHIPPED, Anthropic has ruined it."

Meanwhile the line nobody screenshotted: cache reads rates dropped 75%, to $0.25 per million tokens. Up to 45% off a heavily agentic workload.

That's the part that changes what you build.