Tag: AI Tools

  • You Hit Your Claude Limit. Now What?

    You Hit Your Claude Limit. Now What?

    It happens mid-task. You’re deep in a run — a draft half-built, a coding session finally in rhythm — and the message lands: you’ve hit your usage limit. In Claude Code the banner is plainer about it: “Usage limit reached · wrapping up.” The work isn’t done. The deadline doesn’t care.

    This happens in our shop often enough that we stopped treating it as an emergency and started treating it as weather. You can’t stop it from raining. You can own a roof. This page is the roof: what the wall actually is, what to do in the first fifteen minutes, the structural fixes that keep a limit from stranding work, and how to think about the money when it keeps happening.

    What the wall actually is

    Three different walls get called “the limit,” and which one you hit decides what to do next.

    The five-hour session window. Paid plans run on a session limit: a five-hour window that starts with your first message and resets in full five hours later. It isn’t a rolling drip that refills as you go. It’s a shift. When the shift ends, you’re back — which means a session wall is a scheduling problem, not a crisis.

    The weekly cap. Paid plans also carry weekly limits, and those reset at a fixed time each week that Anthropic assigns to your account. Hit the weekly wall and no amount of waiting until tonight helps; your reset might be days away. This is the wall that actually hurts.

    One pool, every surface. Your chats on the web, the desktop app, your phone, and Claude Code all draw from the same account limits. The heavy coding session you ran this morning is why the chat died this afternoon. Switching apps doesn’t dodge anything — it’s the same tank.

    You can see both clocks in Settings > Usage: a “Current session” bar for the window, and your next weekly reset time printed next to it. Two minutes in that screen tells you which wall you’re looking at, and that’s the first thing to know before you do anything else.

    There’s a fourth wall people confuse with these three: API rate limits. Those are a separate system entirely — set per organization and per model, not per person — and the confusion matters, because the API turns out to be one of the ways around the other three. More on that below.

    If you want the full map — every plan, every price, every limit in one place — that’s our complete guide to Claude pricing, plans, and limits. And if what stopped you wasn’t a usage limit at all but a file or image error, the exact error strings and caps are collected in our guide to Claude usage limits, file caps, and error messages. This page is the other half: not what the limits are, but what you do at the wall.

    The first fifteen minutes

    Minutes 0–2: stop, and read the wall. Don’t re-send the prompt. Don’t open a second chat and try there — same pool, same wall. Open Settings > Usage and see which limit you hit and when it resets. That one fact picks your whole next move.

    If it hit mid-response in Claude Code, land the plane. Claude Code has a small wrap-up allowance: if the session limit lands while it’s mid-step, it may briefly finish the step in progress before stopping. It’s capped, it counts toward your weekly limit, and it’s not generous — on Pro it can happen once per weekly period; on Max, each time the session limit is reached. Use that grace to get the work to a clean stopping point. Do not use it to start something new.

    Get the work out of the chat and into writing. Whatever the job is, produce the state of it: what’s done, what’s next, which decisions are still open, which files were touched. In this shop that’s a handoff note, and it’s the same discipline behind how we run this business on written work orders. A limit strands work only when the context lives in one model’s head. The moment it’s written down, any seat — another model, another provider, you tomorrow morning — can pick it up cold.

    Then pick one of three doors. Park it: the reset is soon and the work can wait — fine, write the note and walk away. Move it: the work can’t wait, so it goes to a different seat or the API (below). Pay through it: turn on usage credits and keep going on the same account (also below). Every bad limit story we’ve lived came from picking none of the three and just pushing on the door.

    The structural fixes a working shop uses

    These are ours. They’re practice, not policy — but they’re the difference between hitting the wall monthly and hitting it never-quite-the-same-way twice.

    Spread the work across seats. We run more than one AI seat, with lanes: different models, and not all of them on one provider’s meter. When one pool runs dry mid-job, the job moves — because the handoff note exists, the move costs minutes, not a restart. A one-model shop has a single point of failure with a five-hour reset.

    Route bulk work to cheaper seats and the API. Summaries, sorting, extraction, first-pass drafts — high-volume work doesn’t need your flagship model or your chat plan’s pool. API usage is billed separately from your plan limits, and a small fast model on the API costs a fraction of what the big one does. Save the plan pool for the work that actually needs you in the conversation.

    Treat your first message like a shift start. Because the five-hour window opens with your first message, the clock is a tool. If you know a heavy run lands at 2 p.m., don’t open the day at 8 a.m. with trivia and arrive at the real work with half the tank gone. Know when your window started; plan the heavy lifts inside it.

    Batch, and keep threads lean. Anthropic’s own best-practice guidance lines up with what we’ve learned the expensive way: batch related requests into one message instead of dribbling them out, plan the conversation before you start it, use Projects for work you’ll return to, and watch the Usage screen instead of guessing. And when a conversation gets long, start a fresh one with a short summary rather than dragging the whole history forward — long threads cost more of your limit with every turn.

    Make the handoff a habit, not a rescue. Every job here ends in writing: done, next, open questions. It reads like paperwork until the day the wall hits mid-job — then it’s the whole business, still moving.

    The money question: credits, upgrade, or API?

    Three levers, in order of commitment.

    Usage credits are the pay-as-you-go lever. On Pro, Max, and Ultra you can turn on usage credits in Settings > Usage. Past your limit, work continues at standard API rates until you hit the spend limit you set; the notice changes to “Now using credits,” so there’s no surprise about which meter is running. Two fine-print items worth knowing before you lean on them: credits are non-refundable, and credits bought on or after December 7, 2026 expire twelve months after purchase. Credits fit the occasional overrun — deadline week, the one big push. Turn them on before the week you need them.

    Upgrading is the flat-rate lever. If you’re at the wall every week, credits are a taxi meter running all month. Max is $100 a month and gives you five times Pro’s usage — every five hours and every week. Ultra is $200: ten times Pro’s weekly usage and, for verified accounts, no five-hour limit at all. Upgrades apply right away, so you can make the call mid-crisis and have the headroom in the same session. We worked through the upgrade math in detail in Claude Pro vs Max: is the $100 upgrade worth it? — the short version: count your wall-days per month; if they’re routine, the flat rate wins.

    The API is the structural lever. API use runs on its own billing and its own limits, separate from your plan. Work that is automated, heavy, or runs while you sleep often belongs there from the start rather than as an escape hatch. One wrinkle worth checking before you pay for anything: Max and Ultra now include monthly API credits — $100 a month on Max, $200 on Ultra — claimable by linking a Console organization in Settings > Billing. Our Anthropic Console guide walks through that side of the account. But keep the buckets straight, because they are genuinely separate: those monthly API credits do not cover interactive Claude Code or extra usage inside the apps, and usage credits are a different bucket again. Mixing them up is an easy way to pay twice for the same wall.

    On a Team plan the same logic runs per seat — Standard and Premium seats carry different limits, and which seats hit walls first is a rostering question. The numbers are in our Claude Team Plan usage limits guide.

    What not to do

    Don’t burn the window on retries. Near the wall, every re-send of a long thread costs more of what’s left, and the reset time doesn’t move because you asked harder. On the API side the same rule is mechanical: a rate-limit error tells you how long to wait, and retrying earlier just fails again. Wait it out or route around — those are the only two moves.

    Don’t open duplicate accounts to dodge the limits. The limits exist so the service stays usable for everyone; accounts opened to get around them are a violation waiting for enforcement, and the day an account closes, everything in it — projects, history, context — goes with it. Even setting the rules aside, it’s fragile operations: a shop whose workflow depends on a workaround has built on sand.

    Don’t confuse the buckets. Plan limits, usage credits, and monthly API credits are three separate things with three separate rules. Most “I paid and still hit the wall” stories are a bucket mix-up, not a billing error.

    The short version

    The wall isn’t the problem. Hitting it with no plan is. Know which wall you hit, write the handoff before you need it, keep a second route warm for the work, and decide the money question — credits for the rare overrun, a bigger plan for the weekly habit, the API for the heavy machinery — while you’re calm, not mid-deadline. The limit will still show up. It just stops being an emergency.

  • Vibe Coding, From a Shop That Ships With It

    Vibe Coding, From a Shop That Ships With It

    I run a small media shop, and most of what we ship now — websites, measurement tools, videos, test programmes — gets built the same way: I describe what I want, an AI builder writes it, and my hours go to steering and checking instead of typing.

    Vibe coding is describing what you want built in plain language and letting an AI builder write the code — you steer with intent and judgment, and it does the typing.

    Andrej Karpathy put the name on it in early 2025: “fully giving in to the vibes.” The phrase stuck because it is honest about the feeling. You stop writing the code line by line. You talk, the machine builds, and you judge what comes back. What the phrase leaves out — and what nobody tells you until you run a real shop this way — is where the work actually went. It didn’t disappear. It moved.

    What it looks like from this desk

    Nobody here opens a blank file and starts chatting at a builder and hoping. The work runs on written work orders: a commission that says what the finished thing is, what it has to connect to, what it must never do, and what proof comes back when it’s done. The builder — we run several, in different seats, with different jobs — executes against that order. Then the return gets checked: not skimmed, checked. Claims get compared against sources. Numbers get tied back to where they came from. Pages get fetched live and read the way a visitor would read them.

    That seat discipline matters more than the model does. A builder with a lane, a written order, and a receipt to produce behaves like a contractor. A builder with a vague prompt and no checking behaves like a confident intern who never sleeps and never admits he’s lost. We wrote up how the seats are governed in our piece on running six AI seats on one business, and the short version is: the structure is the skill. The prompt is the smallest part of it.

    What shipped

    Talk is cheap in this trade, so here is what actually went out the door from this shop, built this way:

    • A citation-measurement programme across a fleet of niche sites. We track where AI answer engines cite our pages and where they don’t, topic by topic, site by site — that map drives what gets written next, instead of guessing.
    • A nightly board that re-pulls our own citation numbers and republishes them. Every night it goes back to the source data, rebuilds the tally, and posts the current standings. If the numbers move, the board moves. Nobody hand-types a figure into it, which means nobody can quietly round one in our favour.
    • Article-to-video pairs, built in-house. Script, scenes, narration, captions — produced here, published as pairs: the article and its video, each pointing at the other. Nine pairs are live. The most recent one is Half the Citations Sit on Three Pages, which is itself a finding out of the measurement programme — the work feeds the work.
    • An anchor experiment, installed live on November 7. We put anchor links on article section headings so each section can travel as its own citable piece — the way a video chapter does. It’s running now and being measured. It might work. It might not. Either way we’ll know from the data, not from a feeling.
    • A full inventory-test programme run against a real product. Not a demo on our own toy data — a scored test, run in the open inside the shop, with results written down whether they flattered anybody or not.

    That’s the part of vibe coding the tool ads get right: the volume is real, and a small shop can ship like a bigger one. Now the other half.

    What broke

    Everything on this list cost us time, and every item on it taught the same lesson from a different angle.

    • Invented facts, caught at the gate. Our page-refresh programme ran in waves, and a pattern showed up in the returns: builders writing plausible, confident, wrong facts into refreshed pages — vendor details, protocol claims, numbers that sounded right and weren’t. None of it shipped, because every claim got checked against a source before publish. But “none of it shipped” is doing a lot of work in that sentence. Without the gate, it all ships. That is the default outcome of vibe coding without a checker: fluent fiction at production speed.
    • A page and its PDF, saying two different things. We’d fix a page and leave its downloadable PDF stale, so a reader with the old file in their own system was working from numbers we’d already corrected. The fix became a standing rule: a page and its download are one asset. The PDF gets regenerated from the corrected content in the same run, or the edit doesn’t ship. The builder never once flagged the drift on its own. A human had to notice the pattern and make it a rule.
    • Runs that stalled on things nobody priced. Quota running out mid-programme. A token that didn’t cover the sites the job needed. A browser on a busy desktop that couldn’t be borrowed. Each one stopped a run cold, and each one was knowable before the run started — somebody just hadn’t checked the whole path to the finish.
    • A redirect job priced at the start instead of the finish. The estimate covered beginning the work, not completing it, and the job froze partway with the loose ends live. It got sorted, but the scar tissue became another rule: price the finish, not the start — the whole path, including whether the human has to stand there while it runs.

    Read those four back and the pattern is plain: the builder’s confidence is not evidence. Not one of those failures was a typing failure. The code worked. The words were spelled right. What failed was truth, scope, and follow-through — the exact things a confident machine will never flag about itself. The operator’s checking is not a quality step added to vibe coding. It is the product. The building is the commodity.

    The honest split of labour

    Here is how the work actually divides in this shop. The machine is fast at the typing and tireless at the volume. It will rebuild a board every night forever and never get bored. It will draft the fortieth page in a wave with the same energy as the first. It does not get tired, and that is genuinely new in the world — a two-person shop with tireless hands.

    The human carries everything the machine can’t: the intent (what should exist and why), the taste (this is good enough, this is not), the fact-check (this claim is true, that one is invented), and the stop button (this run ends here, this door doesn’t open). Those four things sound soft next to “writes code.” In practice they are the whole job, and they were always the whole job — the typing was just where the hours used to hide.

    We have a phrase for it here: partway is the point. The skill isn’t prompting. The skill is knowing which 80% to let run and which 20% is yours — and never confusing the two. Let the machine run the 80% and it will carry you further in a week than a year of typing. Hand it your 20% — the judgment, the verification, the calls — and it will carry you straight into a wall, politely, at speed, with perfect formatting.

    What it is not

    It is not “anyone can build anything now.” Anyone can get something built. The question was never whether the machine can produce the thing — it’s whether the thing is right, and knowing that takes judgment the subscription doesn’t include. Judgment is the scarce input, and it’s scarcer than it was, because now it has to cover ten times the output.

    It is not the end of programmers. Somebody still has to know when the output is wrong, and “wrong” gets subtle fast: the code runs, the page loads, and the fact on it is invented. The people who’ll do best in this aren’t the ones who type fastest or prompt cleverest. They’re the ones who can read a return the way an editor reads a draft — for what it claims, not how it sounds.

    It is not a vibe you can skip verifying. The name is the most dangerous thing about it. “Vibe” suggests the checking is optional, a personality choice for nervous people. In a shop that ships to real readers, verification is the difference between a production system and a fiction generator with good uptime. Give in to the vibes on the typing. Never on the truth.

    So here’s where this shop lands on the term. It sounds like the work got softer — like building things turned into lounging with a laptop and a feeling. From inside, it got more honest. The typing used to hide the judgment; now the judgment is all that’s left, and it shows. A piece either has its receipts or it doesn’t. The facts either check or they don’t. The thing either shipped or it’s a story about shipping.

    That’s a harder standard than the old one, and it’s a better one. We’ll keep building this way.

    Frequently asked questions

    What is vibe coding?

    Vibe coding is building software and content by describing what you want in plain language and letting an AI builder write the code, while you steer with intent and judgment. Andrej Karpathy named it in early 2025, describing it as “fully giving in to the vibes.” In a working shop, the steering and the checking are most of the job.

    Is vibe coding good or bad?

    Neither — it’s a method, and the result depends on what surrounds it. With written work orders, clear boundaries, and a hard check on everything before it ships, it lets a small shop produce at a scale that used to take a team. Without the checking, it produces confident mistakes faster than any method in history. The vibe is not the variable. The verification is.

    Do you need to know how to code to vibe code?

    You need to know how to judge, which is a different thing. You don’t have to write the code, but you do have to be able to tell whether what came back is right — whether the facts check, the scope held, and the thing actually does what it claims. If you can’t tell, you need someone beside you who can. That judgment is the part you can’t hand off.

  • Your Site’s Next Visitor Sends an Agent. Tobira Wants Yours to Meet It.

    Your Site’s Next Visitor Sends an Agent. Tobira Wants Yours to Meet It.

    Ask your AI to do a simple errand: book a call with ten real companies you might buy from. Not research them. Book the call.

    Tobira’s founder, Vlad, ran that exact test before he built anything. He asked his Claude to book a call with 10 real companies. The result, in his launch account, was zero bookings and zero payments. The agent didn’t fail at reading. It failed at the last step — account walls it couldn’t pass, booking pages that block AI, and forms built for fingers and eyes.

    That zero-for-ten is the failure every small business is about to meet. More buyers research inside ChatGPT or Claude, and increasingly ask the same chat to take the next step: book the call, start the trial, place the order. Your site was built for the researcher, not the errand. If the errand dies at your form, you never learn the buyer was there.

    Tobira Site Agent is one vendor’s answer to that break. We have not tested it on our own sites — this is a desk read, built from Dirty Static’s guide to Tobira Site Agent, itself built from Tobira’s maker site and Product Hunt launch post, facts checked November 7, 2026. Where a number comes from Tobira, we say so.

    The clerk, not the brochure

    Most of what businesses have done for AI visitors so far is brochure work: clearer pages, structured content, files an agent can read. Necessary — and it’s the layer we already run. Tobira bets the brochure isn’t enough. A brochure can’t close. A clerk can.

    Tobira puts a site agent of your own on your website, one that lives there, answers questions, and sells — not just to people, but to the AI agents people send. Your site should not wait to be read by a visiting agent. It should send an agent of its own to meet it, answer it, and do the transaction.

    The job list is sales work, not trivia. Per the maker, the agent asks about the visitor’s case, suggests the option that fits, books the call, starts the trial, captures the lead, and sends a payment link — right inside the chat the visitor started in. Booking, trial starts, leads, and payment happen in that chat, not on a separate page. It can talk by voice, with a transcript, and answers in the visitor’s language. When a case gets hard, a person steps in with the chat context attached, so the human isn’t starting from zero.

    Two visitors, one site

    The mechanism is a split. People see your normal website. Visiting agents get a version made for them, built by your agent from your own content. Per the maker, your agent publishes the files agents look for — llms.txt, agent.json, and AGENTS.md — so a visiting agent reads the offer directly and talks to your agent, instead of scraping page after page.

    The token math is the quiet part of the pitch, and it’s a maker example, not a measurement. In Tobira’s worked example, a normal pricing page runs to about 120,000 tokens of page weight. The structured answer lands at about 1,300 tokens, which the company presents as 92 times fewer tokens. Treat that ratio as a company example, not a measured result for your site. Your pages are not their example page. The direction still makes sense: an agent handed the plan, the price, and the next open slot as clean data finishes faster than one guessing its way through your navigation.

    The guardrails are the real product

    A salesperson who improvises prices is worse than none, and a site agent is a salesperson. The important part of Tobira isn’t the booking trick — it’s three guardrails the maker describes.

    First, answers only from your own materials: your site, price lists, PDFs, and FAQs. If the answer isn’t there, the agent doesn’t guess. It offers a call instead. Second, it shares only what you made public. Pricing and plans you chose to publish can be public; internal notes and deal margins stay private. Third, a person steps in on hard cases, with context — the chat history goes to your team, so the buyer never starts over.

    Rules are set in plain words, per the maker — “price ranges only,” “no promised discounts.” If it works as described, the guardrails are the product. The chat is just where they show up.

    Setup and cost

    Setup, per the maker, starts with a scan: Tobira reads your site and builds the knowledge base from what it finds. You add documents, set tone and rules, and test it on the real questions buyers ask. Then it goes live as a badge or widget.

    How long? The founder says 10 minutes on Product Hunt; the product page says 2 minutes. Both are maker claims. The honest reading is minutes, not days — with the real work in checking what the scan learned before you trust it with prices.

    Pricing, maker site checked November 7, 2026, USD monthly before taxes: Free is $0 with your own AI key — Tobira’s fee is zero, the model bill is yours. Lite is $49, about 300 conversations. Start is $169. Business is $399, adding payments, your own branding with no Tobira badge, and voice up to about 1,500 minutes. Premium is $799, up to 3 sites, and on that tier Tobira keeps 15% of AI-subscription revenue. Paid plans carry a 14-day money-back guarantee, and the maker says a data processing agreement comes with paid plans, with data handled under GDPR.

    Free is a genuine test, not a stripped demo. Paid tiers climb fast.

    The network bet

    A site agent alone is a better shop window. Tobira also wants it to be a doorway into a market. Per the maker, your agent gets a public address in the Tobira network — an email-shaped handle, but for AI. When another company’s agent looks for what you offer, the two agents talk first and check fit. You get a qualified deal, or silence.

    The founder says the network holds more than 800 agents. That is a company figure, not audited, and a network is worth what its members are worth — from outside today you can’t tell a market from a list.

    Where this sits in our own house

    We’ve written this pattern before, from the other side. In October, after Kin’s WebMCP launch, we published “The Agent-Ready Site”: welcome the machine, structure the content, give the agent a way to act, measure what it does. Our fleet runs three of those four layers today. Our llms.txt has been live since October 2026, roughly 62% of our traffic is bots rather than people, and we measure the machine side with Bing’s citation exports.

    Tobira is what the unbuilt layer looks like when a vendor builds it for you. The missing layer was the third: give the agent a way to act. An llms.txt is the brochure on the door — it tells a visiting agent what you offer, in its own language. A site agent is the clerk behind it — it answers back, books, and takes payment. Same argument, next step. The pattern said structure your content for agents. Tobira’s bet is that the structure should be a salesperson.

    For the record: Tygart Media has not installed Tobira or run it on a client site. It’s a live commercial answer to a layer we know is missing.

    The two questions that decide it

    One: do your buyers send agents yet? The whole model depends on buyers asking their AI to book and buy, still a young habit. Every speed figure Tobira publishes — including its “2.2 times faster” claim — is founder-tested, not from an outside lab. If your customers still call and complete forms without trouble, a good booking page beats an agent you have to feed.

    Two: are your materials clean enough to be spoken aloud? An agent answering only from your materials is only as good as those materials. A stale price on a page is an embarrassment. A stale price spoken with confidence by your own agent, with a payment link attached, is worse than no agent at all.

    If your buyers already arrive through AI and die at the booking step, the free route is worth a real test. If they don’t, watch the habit and the network count, and keep your booking page in good shape. Guessing wrong about which one you’re in is the expensive option.

    The practice

    Run the founder’s test on yourself. Open the AI you actually use and ask it to book a call with your business — your real site, no help from you. Watch where it dies. If it books cleanly, your forms were never the wall; file this category under “later.” If it stalls at an account wall, a blocked page, or a form it can’t complete, you’ve just watched the exact failure Tobira is selling against — free, in ten minutes, on your own storefront.


    Want this thinking applied to your own business? Book a call with Will Tygart — 30 minutes, and we start from your receipts, not a pitch deck.

  • The Coding Ladder Says the Dial Pays. Our 52 Calls Said It Didn’t. Both Numbers Are Real.

    The Coding Ladder Says the Dial Pays. Our 52 Calls Said It Didn’t. Both Numbers Are Real.

    Yesterday we published a test: 52 calls to Muse Spark 1.3, seven kinds of work, every rung of the reasoning dial, everything scored against ground truth. Our result was not close. The cheapest setting never lost — and twice, extra thinking was the failure itself. We set the fleet’s operating rule on that evidence and moved on.

    Then a counter-check showed up, the way we’d want one to. BenchLeader — a third-party site that republishes benchmark results from their original publishers — carries a full rung-by-rung row for Muse Spark 1.3 on CursorBench, a coding benchmark. On that ladder, the dial pays at every single rung. If both results are real, they can’t both be the whole story. So we read the ladder the way we ran our own test: numbers first, bases stated, no vibes.

    The ladder’s numbers

    CursorBench, Muse Spark 1.3, as published on BenchLeader (data as of November 8, 2026; the underlying results are Cursor’s, dated September 2, 2026):

    Rung Tasks solved Rank on the board
    minimal 24.3% #79
    low 29.3% #72
    medium 32.6% #64
    high 33.4% #59
    xhigh 37.5% #48
    max 41.6% #38

    No rung regresses. Every step up solves more tasks than the step below it — +5.0 points from minimal to low, +3.3 to medium, +0.8 to high, +4.1 to xhigh, +4.1 to max. Across the whole ladder that’s +17.3 points: at max, the model solves roughly 1.7 times the share of coding tasks it solves at minimal. Ranks are among 82 model configurations with a published result on that benchmark.

    What is CursorBench? In BenchLeader’s words, it’s “Cursor’s internal coding-agent evaluation”: coding tasks run inside Cursor’s agent, with the reasoning level and cost per task recorded, scored as the percent of tasks solved. Two honest labels belong on it. It is published by a coding-tool vendor — BenchLeader itself flags “harness is theirs” — and BenchLeader carries it for reference only; it doesn’t count toward their composite index. It is still the only rung-by-rung coding evidence for this model that we know of, and it points the opposite way from ours.

    Our numbers, on the record

    Our battery was 52 API calls to the contributor tier of Muse Spark 1.3, November 6–7, 2026, identical prompts at multiple settings, mechanical scoring. The buyer-brief judgment task scored identically at every rung — minimal got it for 776 reasoning tokens and 6.5 seconds, xhigh for 6,847 tokens and 50 seconds. Verdicts at scale: 120 out of 120 at low, 120 out of 120 at xhigh. Planning: provably optimal schedules at every rung.

    And the coding cell — the one this ladder speaks to directly. Our debugging task was one function with three planted bugs. Every rung found the inverted discount logic and the rounding bug; the cheapest setting found all three. One xhigh call spent its entire 8,000-token budget thinking — 7,998 reasoning tokens — and returned an empty answer. It thought so long it never spoke. Minimal answered the same task correctly with 500 reasoning tokens.

    Our published conclusion: on our work, extra reasoning bought latency, not quality, and the operating rule became low by default, with xhigh and max earned only by a demonstrated failure at low.

    Both numbers are real. The tasks aren’t the same.

    Put the two bases side by side and the disagreement gets smaller and more specific:

    • Task shape. CursorBench runs coding tasks inside an agent — sustained, multi-step work where the model plans, acts, reads errors, and recovers over many turns. Our battery was single API calls with a checkable answer. Our one coding task was a single function, solved — or stalled on — in one shot.
    • Tier and harness. The ladder ran Spark 1.3 inside Cursor in September. We ran the contributor tier through the API in November.
    • Measurement. The ladder reports the percent of a task set solved. We scored one sample per cell against ground truth — a limit we printed in the original piece.

    Here is our reasoning, labeled as reasoning and not as either source’s claim: the reconciler is task shape. On a short, bounded task with a checkable answer, the first think is the one that does the work; rungs above it buy patience-testing latency, and occasionally a stall. On a long agent run — hold a codebase in mind, take twenty steps, survive your own mistakes — extra reasoning has something real to chew on, and the ladder pays for it. That reading fits the anomaly we flagged in our own data: the rungs behaved like task-shaped budgets, not fixed ceilings. It also fits the limit we printed: we never tested sustained work. CursorBench did — or rather, Cursor did.

    What would change the verdict

    Not an argument. A run. The test that settles this for our shop is our own coding work at every rung: real work-order-shaped jobs — a written spec, more than one file, a module plus a test suite with a mechanical pass/fail — at minimal, low, high and max, in one harness, more than one sample per cell, receipts published the way the first battery’s were. If low matches max on those, our rule stands for coding too, and the ladder is a story about Cursor’s harness. If max pulls away as the jobs get longer, the rule gets a carve-out: the rung follows the length of the task. Either result is publishable. We’ll run it and print what we find.

    The bottom line for an operator

    If your work is short, bounded calls — extraction, checking, verdicts, drafting to spec — run low. We have 52 metered calls that say the expensive rungs buy you nothing there, and our default hasn’t changed.

    If your work is a coding agent chewing through real jobs, the only rung-by-rung evidence that exists says turn it up: on Cursor’s own ladder, max solves 41.6% of tasks against minimal’s 24.3%, and every rung between them earns its step. That evidence is a vendor’s, run in the vendor’s harness, on September’s model build — hold it at that weight, not more.

    The mistake isn’t picking the wrong rung. It’s running one default across both shapes of work and calling it a policy. The dial is real. What it pays for depends on the length of the job in front of it — and now there are two published result sets, ours and Cursor’s, that say exactly that from opposite ends.

    Sources: BenchLeader, “Muse Spark 1.3” model page and CursorBench leaderboard (data as of November 8, 2026; CursorBench results published by Cursor via the Epoch AI Benchmarking Hub, Spark 1.3 results dated September 2, 2026). Our dial test: “We Ran Muse Spark’s Reasoning Dial Through 52 Calls. The Cheapest Setting Never Lost.” (Tygart Media, November 7, 2026), method and receipts in the Tygart-OS fact-gated fleet record on GitHub.


    Want this thinking applied to your own work? Book a call with Will Tygart — 30 minutes, and we start from your receipts, not a pitch deck.

  • How We Track Whether AI Cites Us

    How We Track Whether AI Cites Us

    Updated November 2, 2026 — added direct answers on prompt citation triggers, assistant mentions, and tracking tools, from our own published measurement.

    Every week there is a new tool that promises to track your “AI visibility,” and most of them are selling a number they invented to a market that can’t check it. We track whether AI cites us for a living — a small fleet of sites, measured monthly — and our whole stack costs nothing. What it costs instead is discipline: knowing what each instrument actually measures, which cells in which reports lie, and which three numbers are worth your attention. This is the stack, the method, and the traps, from the reports we pulled today.

    Start with the engine’s own ledger

    Bing Webmaster Tools has an AI Performance section, it is free, and almost nobody in this business has opened it. It reports two things no third-party tool can know firsthand: the grounding queries — the actual questions for which Copilot and Bing’s AI answers pulled your pages as sources — and your citation share of each one. A third-party tracker samples AI answers from the outside and guesses. This is the engine’s own bookkeeping. If you do nothing else in this article, connect your site there and pull the two CSVs: AI Search Queries and AI Page Stats.

    Read the two reports against each other, because individually they will lie to you in specific, learnable ways. Today, a filtered export for one of our sites showed a grounding query with 2,796 citations and a citation share of 0.00% — an impossible pair. The page report for the same window showed our page taking 2,790 of those citations. The share cell in a filtered view was simply broken. The lesson is not “the data is junk.” The lesson is that a citation number is only as good as the second report that confirms it.

    Can I see which prompts trigger citations of my site?

    Yes. The most accurate way to see which prompts trigger citations is through the engine’s first-party ledger. In Bing Webmaster Tools, the AI Search Queries export within the AI Performance section lists the exact grounding queries—the actual questions asked by users for which Microsoft Copilot and Bing AI answers pulled your pages as cited sources—along with your citation share for each query. For engines like ChatGPT, Claude, Perplexity, and Google AI Overviews that do not provide a native webmaster ledger, you can see trigger queries by running scheduled prompt panels across a fixed sample of buyer questions to observe directly which queries generate citations for your domain.

    How do I know if my content is being used in AI answers?

    You confirm content usage by checking both sides of the connection: the engine’s ledger and your own site analytics. In Bing Webmaster Tools, open the AI Page Stats report to view the exact URLs on your site that AI answers cited as grounding sources, including citation counts per page over trailing windows. On your own site, cross-reference those cited URLs with server log exports to verify AI crawler activity, and monitor response-side analytics such as Microsoft Clarity and GA4 to see whether citations are translating into user sessions and on-page engagement.

    The three numbers worth watching

    One: citation share on the queries that pay. Not total citations — share, on the handful of questions your buyers actually ask. Share is a rate over a trailing window, not a switch that flips, so judge it the way you’d judge a batting average: this month’s window against last month’s, same instrument, same site. A share that climbs two windows in a row is the engine changing its mind about you. A share that jumps once is weather.

    Two: the per-page trend. Page-level citations tell you where the engine is consolidating. Our certification page for restoration contractors climbed four straight exports — 1,635, then 1,913, then 2,454, then 2,790 citations — while its near-duplicate twin collapsed from 304 to 6. That is the engine picking a winner between two similar pages, in public, in numbers you can watch. When you see it, feed the winner: better structure, tighter answers, the cluster’s links pointed at it. When you see the split instead — two pages dividing one topic’s citations — you have found the leak.

    Three: new grounding queries. Every export contains questions you have never seen, some of which you are already being cited on without knowing it. Those are the cheapest wins in the whole system: the engine has already decided you are relevant; a page that answers the question directly, in the asker’s words, converts a toehold into a position. Half of what we publish starts as a line in this report.

    How do I track which AI assistants mention my business?

    Tracking AI assistant visibility requires distinguishing between a mention and a citation. A mention occurs when an assistant includes your brand or company name in its generated answer text without linking to your site. A citation occurs when the engine explicitly footnotes or links to your URL as a grounding reference. Engine-native ledgers like Bing AI Performance track grounding citations, not unlinked text mentions. To track text mentions across ChatGPT, Claude, Perplexity, and Google AI Overviews, you must audit full assistant responses using manual prompt sampling or third-party panel tools that inspect response copy for unlinked brand names alongside citations.

    The second instrument: what people do after the click

    Microsoft Clarity is the other free half of the stack — session recordings, heatmaps, and an export API — and it answers the question citation reports can’t: what happened when the visitor arrived. Its limits are just as instructive. Clarity masks typed text by design, so a search box can light up with clicks while the actual search terms never appear in a recording. We learned to read the terms out of the URLs instead — a completed site search carries its query in the address — and when we pulled three days of URLs across two sites this week, we found a search box that had drawn 69 clicks and zero completed searches. The box was being touched constantly and used never. No dashboard said that. Two exports and ten minutes of reading did.

    Clarity also ships AI summaries of your traffic, and our rule for those is blunt: a summary is a lead, never a fact. Session counts and page claims get settled by the raw export or a live fetch, because the one time it matters is the one time the summary will be confidently wrong. Treat every AI-written summary of your own analytics the way you’d treat an AI-written summary of anything: as a rumor with good formatting.

    What the paid trackers add — and what none of them can see

    Paid visibility trackers earn their money on breadth: they run panels of prompts against ChatGPT, Claude, Perplexity, and Google’s AI surfaces, where Bing’s report covers only its own family. If your buyers live on those engines, a panel tool tells you things the ledger can’t. Buy breadth if you need it. But understand what you’re holding: a sample of answers, taken at a moment, from accounts and locations that may not match your buyers. It is a poll, not a census. The engine’s own report is the census for its engine — narrower, and exact.

    What no tool in this category can see is your side of the wall: which pages your own visitors touch, what they search for on your site and fail to find, which of your URLs the bots are actually crawling. Roughly six in ten visits across our fleet this month were automated, and that share climbs every month. Any visibility number that doesn’t ask “of the humans or of the machines?” is averaging two different worlds into a fiction. Your own logs and exports are the only place that question gets an honest answer.

    How can I check whether ChatGPT cites my website?

    Because OpenAI does not offer a public webmaster ledger comparable to Bing’s AI Performance dashboard, checking whether ChatGPT cites your website requires two complementary approaches. First, run prompt-level sampling: submit your core target buyer queries directly into ChatGPT with web search enabled, and inspect the resulting answer footnotes and web sources to verify whether your specific URLs appear. Second, monitor your response-side traffic in GA4 and web server logs: track referral sessions originating from chatgpt.com, review GA4’s native ai-assistant channel medium, and set up custom referral channel filters to identify visitors arriving via ChatGPT citations.

    The tool categories, compared honestly

    Search for answer engine optimization tracking tools and you will find four kinds of instrument wearing the same label. Engine-native ledgers — Bing Webmaster’s AI Performance reports are the working example — show the grounding queries and citation shares from inside one engine family: narrow, exact, free. Behavior analytics like Microsoft Clarity show what visitors did after the click: also free, also first-party, blind to anything that happens off your site. Paid panel trackers run batteries of prompts against ChatGPT, Claude, Perplexity, and Google’s AI surfaces and report how often you appear: broad, sampled, and only as representative as their prompt list and accounts. Your own server logs and exports are the unglamorous fourth category, and the only one that separates human visits from the bot traffic that now makes up the majority of most sites’ requests.

    None of the four replaces another, and the marketing of each pretends otherwise. The ledger can’t see ChatGPT. The panel can’t see your visitors. The analytics can’t see the citation that never became a click. A working stack layers them in that order — ledger first because it’s ground truth for its engine, analytics second because behavior is where money is made, panels third if your buyers live on engines the ledger doesn’t cover, and your own logs underneath everything as the lie detector. Anyone selling you a single tool as the whole answer is selling the tool, not the answer.

    What tools measure AI search visibility?

    Tools that measure AI search visibility divide into four distinct categories, each serving a specific role in a measurement stack:

    • Engine-native ledgers: Free first-party platforms—specifically Bing Webmaster Tools AI Performance—that report verified grounding queries and citation shares directly from the engine family’s internal logs.
    • Behavior analytics: Free response-side analytics—such as Microsoft Clarity for session recordings and heatmaps, paired with GA4—to measure what visitors do after clicking through from an AI answer.
    • Paid panel trackers: Third-party prompt-monitoring software that repeatedly queries panels across ChatGPT, Claude, Perplexity, and Google AI Overviews to sample comparative visibility and citation rates.
    • Server logs and exports: Your own web server request logs, which act as the ultimate truth layer by tracking crawler user agents and distinguishing automated bot activity from genuine human traffic.

    The discipline is the product

    The stack is two free Microsoft tools and a spreadsheet habit. The method is: same reports, same window, read against each other, three numbers, every month, and a standing suspicion of any figure that arrives without a second source. None of that is purchasable, which is exactly why the tools market would rather sell you a score.

    Skip the score. Pull your grounding queries. Find the page the engine is consolidating onto and the twin it is starving. Read your new questions like a suggestion box written by the market itself. That is tracking AI visibility — not watching a gauge, but reading the engine’s mail. It has been sitting in a free dashboard the whole time.

  • Wonder Full Stays in the Seat. The API Key Is a Different Promise.

    Wonder Full Stays in the Seat. The API Key Is a Different Promise.

    On October 12, 2026, Meta launched two models that share a name and almost nothing else. Muse Wonder is a product you can call: it sits on the Meta Model API at $4.00 input, $0.20 cached input, and $20.00 output per million tokens, and inside Muse Code. Muse Wonder Full is a model you can only sit in front of: it exists exclusively inside a Muse Code subscription, on the Power Usage and Maximum Usage plans. The decision an operator makes before pointing either one at a real repository is not which model is smarter. It is which promise they are buying — and the seat’s default promise is not the one most buyers think they made.

    The frontier model is a seat, not a SKU

    Meta’s own availability table is the whole story in four cells. Muse Wonder (muse-wonder-1.0): available on the Model API, standard mode only, and in Muse Code on pay-as-you-go and every plan. Muse Wonder Full: not available on the API at all — Power Usage and Maximum Usage subscriptions only.

    There is no back door. Setting reasoning effort to “max” on muse-wonder-1.0 does not select Wonder Full; Meta’s models page says so in plain words. Meta publishes no API model ID for Full. A team that wants Full behind its own product has, in the words of one launch-week review, no path at any price — businesses can test it inside Meta’s coding environment and cannot deploy it through the standard API.

    The seat prices are printed on the Muse Code product page: Everyday Usage $5 a month, High Usage $15 at 5× the Everyday allowance, Power Usage $50 at 20×, Maximum Usage $200 at 80×. Power is the cheapest chair that includes Wonder Full. The allowances run on five-hour and weekly resets, and per the Terms, a subscription’s per-period allowance expires at the end of each period and does not roll over. On Maximum, when the allowance is gone, Meta’s documented way forward is to wait for the refresh.

    The credential is a leash

    The subscription applies to the API key Meta automatically connects during Muse Code CLI onboarding, and the subscriptions doc is explicit about the boundary: “This credential is for use with Muse Code only.” The Terms give the arrangement its legal name — a Coding Harness Subscription — and the same restriction: the connected key “may not be used to access the Services outside the coding harness or to circumvent your subscription’s usage limits or billing.”

    Any additional API keys you create under the same account are billed pay-as-you-go, per token. So one Meta account holds two different commercial relationships at once: a flat seat that works only inside one CLI, and metered keys that work anywhere except that they can never call the frontier model. Budget them as two products, because Meta does.

    The default is the decision

    Here is the trap, and it is set by a default. “Muse Code subscriptions default to Contributor mode. In Contributor mode, you get more usage from your plan in exchange for letting Meta use your content — the prompts, code, files, and context you send, plus the model responses you get back — to train future Meta models.”

    A careful buyer can still walk into it. Meta’s Model Designation Policy lists Muse Wonder and Muse Wonder Full as Standard Models — the tier whose use constitutes Standard Services, where content is not used for training. The same policy then overrides the list: “If you access the Services through a Coding Harness Subscription, you are considered to be using the Contributor Services by default regardless of which Meta Model you select.” Terms section 3.3 says the same. In Muse Code, Contributor mode is not a model name. It is a subscription setting, and it is on.

    Turning it off is one toggle: open /settings in Muse Code. The help page states what the toggle does and does not do: “Turning Contributor mode off changes how much usage you get from your plan. It doesn’t change which plan you’re on.” How much usage changes, Meta does not publish — no ratio, no prompt count, no price difference appears in the documents. The honest line for a budget is that the size of the privacy discount is undocumented.

    Meta’s own warning belongs in every seat-setup checklist, quoted exactly: “You must not submit sensitive, confidential, or personal information to the Discounted Services. If your use case involves processing personal information, please use Standard Services.” Accounts with Zero Data Retention cannot use Contributor mode at all — and ZDR itself is an organization-level enablement Meta’s sales team turns on for Model API accounts, not a toggle in the CLI, and it does not cover requests made with a personal account.

    The switch does not reach backward

    The off-switch is prospective. Terms section 3.3: a change to Standard applies “prospectively only; it would not apply to Content previously submitted to the Contributor Services, and Meta’s rights with respect to that Content under Section 6 will survive the change.” Everything a seat sent while the default was on stays under the training grant after you flip the setting.

    Section 6.1 adds the subtler pull: “Content previously submitted to the Standard Services becomes Content submitted to the Contributor Services if it is included in any request to the Contributor Services, whether directly or as context or background for your prompts or instructions.” One later Contributor-mode session that pulls an earlier, clean conversation in as context reclassifies that content.

    The commitments page softens the arrangement with a safeguard and then qualifies it: before using Discounted Services content to train models, Meta “takes steps designed to disassociate that Content from your Accounts” — but Meta may use the same content for “evaluation, safety, abuse, quality, and policy review” without first applying those steps. And section 6.1 acknowledges the output side: models trained on your content may produce outputs “similar or identical to your Content,” including for third parties.

    The API shelf is labeled honestly

    On the API, the same choice exists — as a separate model name, printed on the pricing page where a buyer can see it. Contributor mode “isn’t available for Muse Wonder on Model API.” For Spark it is a different SKU: muse-spark-1.3-contributor and muse-spark-1.2-contributor at $0.10 input, $0.002 cached, $0.20 output per million tokens, against standard Spark at $1.25 / $0.15 / $4.25 — capped at 150 requests per minute against 3,000 for the standard IDs. The Muse Code product page labels the two rows without euphemism: the Contributor row is “Used to improve our products”; the standard row is “Not used to improve our products.”

    That is the contrast the seat hides. On the API, training is a priced, named, rate-limited variant a buyer selects on purpose. In the subscription, it is the factory setting of the harness — and the model table’s “Standard Model” label will tell a skimming buyer exactly the wrong story about which arrangement they are in.

    The operator’s checklist

    Decide the data arrangement before the repository, not after the first session. A public demo and a confidential codebase can run through the same agent on the same afternoon; they require different settings, and the setting is per-subscription, not per-conversation.

    Turn Contributor mode off in /settings before any client code, customer data, or contract-confidential material enters the seat — remembering that the flip protects only what is sent afterward, and that earlier standard content follows it if it is ever pulled back in as context.

    Buy the seat for the seat’s work. Wonder Full is a genuinely frontier tool for a person at a keyboard, and it is not a component. Anything your own product must call belongs on the API, in Standard mode, on keys you budget per token.

    This desk tracks Meta’s platform as it changes; the full rate card and the contributor tier’s arithmetic are in Meta Model API Pricing & Limits, and every Meta piece hangs off the Meta AI desk hub. The short version to tape above the desk: the model in the seat is not the model on the shelf, and the seat’s most consequential setting is the one nobody remembers choosing.

  • Move the Design System Before December 14 — the Chat Does Not Come With It

    Move the Design System Before December 14 — the Chat Does Not Come With It

    Sunset Notice (Verified Nov 19, 2026 · 25 Days Left) · Standalone Claude Design Closes December 14, 2026

    Standalone Claude Design (claude.ai/design) sunsets December 14, 2026, when Anthropic folds design workflows into integrated Claude and Artifacts. On-site successor guide: Claude Artifacts: What They Are and How to Use Them. Per Anthropic’s claude.ai/design migration notice, migration transfers eligible custom design systems only — standalone chats, comments, public project links, and unmigrated originals must be exported manually before December 14.

    MIGRATION CHECKLIST PDF & MARKDOWN TWIN
    Standalone Claude Design Sunset Checklist (Dec 14 Deadline)
    Verified November 19, 2026 (25 days remaining until December 14 closure): printable 7-step export & migration checklist PDF + Markdown twin.

    The standalone Claude Design site at claude.ai/design closes on December 14, 2026. After that date, the address opens Claude. Anthropic’s announcement gives the reason in one sentence: “Running two versions slows down fixes for both, so we’re folding the standalone site into Claude.”

    The migration that Anthropic offers moves design systems. It does not move projects. And the parts of your work that live only in the standalone product — the chats, the comments, the originals — have a deletion date, not a transfer path. This is the procedure for a team that has brand systems and client one-pagers in there, in the order the steps have to happen.

    What gets deleted, exactly

    Anthropic’s migration guide names the deletion list in two bullets: “Your chats with Claude” and “Comments on your projects and design systems.” Those stay in the standalone version and are deleted after it closes, per Anthropic’s data retention practices.

    Your originals are a separate statement, in the guide’s FAQ: they keep working in the standalone version until it closes on December 14, 2026, and “after that, they’re deleted.” A design system you migrate leaves its original behind in the standalone product, unchanged — and that original is on the same clock.

    Public links to standalone projects are a third outcome, and the guide words it differently on purpose: they “will no longer work after it closes.” Not deleted — dead. Every client you sent a public project link to holds a URL with an expiry date.

    The instruction Anthropic prints is the whole strategy for this section: save anything you need from your chats and comments before the standalone version closes. No fetched Anthropic page documents an export for chats or comments. The capture that matches the documentation is a screenshot of each comment thread and a copy of the chat text, done by hand.

    The dangerous sentence: “You don’t need to do anything with your projects yet”

    That sentence is in the migration guide, and it is true — your projects keep working in the standalone version until the close. It is also the sentence that will get client work deleted, because projects are the files with no migration path and a deadline.

    The Artifacts page in Claude lists up to 60 of your standalone projects, and they open in the standalone version. That list is a directory back into the product that is closing. It is not a move, and it is not a complete inventory if your team has made more than 60 projects. Anthropic’s position, in the guide’s words: “More details about moving your projects to Claude are coming soon.” Soon is doing a lot of work in that sentence, and December 14 is 25 days out (as of November 19, 2026).

    So the inventory step happens in the standalone product itself, not on the Artifacts list. Walk the standalone library for every client one-pager, deck, and brand system — including everything past the first 60 the Artifacts page shows.

    Before anyone clicks Migrate: the sharing problem

    One migration brings over every design system in your organization, including other people’s. It only needs to be started once — and anyone who can use Claude Design can start it, not just the organization’s owners. On individual plans there is no confirmation step at all: click, and it starts.

    The consequence that matters for a shop holding more than one client’s brand: “Published design systems that aren’t private will be shared with everyone in your organization and appear in their design system menu.” A system you published so your own projects would use it becomes an entry in every teammate’s menu the moment anyone runs the migration. On individual plans, nothing is shared — this is a team and organization trap, not a solo one.

    The precaution has to happen before the first click, because undoing it is not documented. In the standalone product, the setup guide names the Published toggle as the control that makes a system the organization’s working system. For every design system that should not appear in the whole organization’s menu, turn that toggle off first. A second migration is not a way back: a later run leaves an unchanged system alone and skips one that has changed inside Claude, so neither pass pulls a system out of the menu.

    Two kinds of systems do not migrate at all, no matter who clicks: “Empty design systems aren’t migrated, and neither are ones made from a built-in starter theme, even if you’ve edited them.” If your house brand began life as a starter theme you customized, the migration will silently leave it behind. There is no documented design-system export to fall back on. Copy the source assets out by hand before December 14.

    The export drill: one project, one zip

    There is no bulk download. Anthropic’s FAQ is blunt: “Not all at once. You can download them one at a time.” Open the project in the standalone version, click Share, choose “Project HTML” — for a slide deck, that item hides under “More formats and apps” — keep “Project archive” selected, and click Export.

    You get a .zip file with every file in the project. It is free and does not count toward your usage limits. Repeat it for every client one-pager and deck you cannot afford to lose, and store the zips outside Claude.

    Know what the zip is not. It is documented as every file in the project. Chats are on the deletion list, and no Anthropic page says the conversation comes along inside the archive. The zip preserves the files. The reasoning your team talked through in chat, and the client’s comments on the work, survive only if you captured them in the previous step.

    Enterprise: three switches, and one hard stop

    On Enterprise plans the migration is gated by settings that are easy to flatten into one wrong sentence, so take them separately. Artifacts themselves must be on — if they are off, people cannot migrate anything and will not even see the “Claude Design lives here now” banner.

    Design systems are a separate template switch: on for Team plans, off for Enterprise until an owner turns on Design systems in Organization settings > Artifacts. That is a different switch from Design and Slides, which Anthropic’s pages say were set to turn on by default on October 15, 2026 — a date that has now passed, with the help text still printing the scheduled sentence, so check your own settings rather than assuming either state. On plans with custom roles, each role also needs the Artifacts permissions, and a design system cannot be migrated if its owner’s role does not include design systems.

    The hard stop: “Organizations with zero data retention (ZDR) can’t turn on artifacts, so they can’t migrate.” If that is your organization, the migration procedure does not exist for you. The guide’s path is the per-project download, done before the close, one zip at a time.

    One more setting that does not do what an admin might hope: the Enterprise custom-retention article states that custom retention periods “do not apply to Claude Design.” The retention dial your organization already configured is not the instrument that keeps or deletes standalone chats, comments, or originals. The closure is.

    After it lands

    A migrated design system keeps its files as they were, and it cannot be hand-edited on its page yet. Its editors see the note: “Migrated from the standalone version. Ask Claude to make changes.” The editing model for a migrated brand system is a conversation, not a settings page.

    If someone edits a migrated system inside Claude and you later run the migration again, that system is listed under Skipped — “changed on claude.ai, left as they are” — so your edits are not overwritten. Replacing it with a fresh copy is a deliberate act: duplicate it first if the Claude-side changes matter, delete it in Claude, then migrate again.

    New design work lives in three doors now: any chat (ask for a design, or Output > Design in the message box), the Artifacts tab, and Claude Code, with /design to create, edit, and sync designs and /design-sync to pull in your design system. All of it draws on the same usage pool as the rest of Claude, including Claude Code — the separate weekly Claude Design allowance the product launched with is already gone, per the get-started guide.

    Two gaps in the new home are worth knowing before you move the team: Claude Design does not have version history yet, and inline comments there occasionally fail to appear on the page — Anthropic’s own workaround is to paste the feedback into the chat instead. The standalone product’s comment threads, the ones being deleted in December, are still the reliable record until you screenshot them.

    The order is the procedure

    Inventory in the standalone product. Turn off Published on anything that must not become an organization-wide menu entry. Mark the empty and starter-theme systems the migration will refuse, and copy their assets out by hand. Export every project that matters, one zip at a time. Screenshot the comments and copy the chats. Only then — owners having turned on Artifacts, Design systems, and the role permissions — does one person click Migrate, read the results window, and fix any failed system in the standalone product before running it again.

    Do those steps in that order and December 14 is a non-event: the address starts opening Claude, and everything you cared about is already there or already saved. Do them out of order — migrate first, inventory later — and the button will happily move the systems while the projects, comments, and originals sit in a product with 25 days left on it (as of November 19, 2026). We track vendor surface changes like this one on the desk because the procedure is always in the help pages; it is just never in the announcement. The announcement for this closure said chats and comments “won’t be available.” The help center is the text that says deleted.

    Sources: Anthropic’s migration guide, Migrate from standalone Claude Design to Claude, and the get-started guide, Get started with Claude Design, both read in full on October 19, 2026. A related surface change, worked the same way: Cursor’s shareable canvases, and how we check a vendor’s what’s-new claims in What’s New in Cursor Is a Claim.

    MIGRATION CHECKLIST PDF & MARKDOWN TWIN
    Save the Exact Export & Migration Order (Dec 14 Sunset)
    Verified November 19, 2026 (25 days remaining until December 14 closure): printable 7-step export & migration checklist PDF + Markdown twin.
  • Review the Run, Not the Diff: Cursor’s Shareable Canvases in a Fleet Loop

    Review the Run, Not the Diff: Cursor’s Shareable Canvases in a Fleet Loop

    What shipped on October 16

    Cursor’s changelog entry dated October 16, 2026 — “Cloud Agent Canvases and Environment Improvements” — is three short sections long, and one of them changes the shape of a finished run: “Cloud agents can now build interactive canvases as part of their work. Share a finished canvas with your team by sending its link.” That sentence is Cursor’s. Everything in this section is theirs, from that changelog entry and the Canvases page of their docs, read October 19, 2026.

    A canvas, in their docs, is an interactive artifact that renders next to the chat: a standalone view laid out with sections, stats, and tables, instead of a long markdown table or a code block to scroll through. Ask an agent for a dashboard, an analysis, an audit, or a report, and Cursor opens the result in a canvas when a visual view is the better fit. The canvas is saved to the workspace’s canvas list, so you can reopen it, edit it, and rerun it later with fresh data.

    Sharing is a publish, not a forward. From the canvas toolbar you Publish — which publishes a share or refreshes an existing one — then copy the link and send it. What the link opens is a live snapshot: the same layout, charts, and tables, without rerunning the agent and without digging through the chat history. Teammates open it in the browser with read-only access. A Shared Canvases page on the dashboard lists the shares you published yourself, so you can reopen, copy, or delete your own; it does not list a teammate’s shares — for those, you ask for the link.

    The same release carried two more items, logged here for completeness. The Environments API is available in beta: a programmatic way to create and manage the cloud environments agents run in. And the environments themselves grew: up to 300 repositories per environment, with large environments loading 5x faster — Cursor’s numbers, not measurements of ours. Neither item is this piece’s subject; both are on the desk’s check list.

    The gate is part of the story

    A canvas link is not a public link. The docs are explicit: anyone on your team can open the link in the browser. Only members of your team can open a share, and you need to be on a team to share at all. Sending the link outside the team sends a door the recipient cannot walk through — which makes the canvas a team surface, not a publishing surface.

    Sharing is also a paid-plan surface with conditions attached. Shares can be created on paid plans — Premium and higher, Teams, Enterprise, and the legacy Pro, Pro+, and Ultra tiers; free accounts cannot create shares. Sharing requires a privacy mode that allows data storage, so Legacy Privacy Mode blocks it. And a team admin can turn shared canvases off for the whole organization from team settings. A shop adopting the feature checks those three gates before it builds a habit on them.

    A snapshot is not the run itself. The canvas shows the view as published; the chat, the reasoning, and the diff stay behind it. When the underlying numbers move, the share does not move with them — refreshing it is another Publish. A reviewer who needs the execution record still goes to the record. The canvas is the board on the wall, not the flight recorder.

    Where it lands in our loop

    Our loop fits in one sentence: a work order is written with everything the executor needs, the agent flies it, and the result is debriefed at the receiving end — the live page checked in a browser, the delivered file opened, the count re-added by hand. The debrief is where quality is decided here, and its surface depends on the seat. A cloud run launched over the API hands back result text. A Desktop sitting hands back a transcript and screenshots at verification points, which this shop trusts over any summary.

    A canvas inserts a third surface into that debrief: the agent arranges its own evidence — sections, stats, tables — into the board the reviewer actually opens. For the data-heavy work this shop runs constantly — citation pulls, model-catalog diffs, site audits — a rendered board is the shape the answer wanted anyway. Cursor’s docs make the same point from their side: canvases earn their keep on data-intensive tasks, where information arranged non-linearly is easier to digest than a wall of text.

    The approval moment in this shop is a tap on finished work. Will reviews results, not work in progress, and the decision lands on an artifact he can read in one pass. A canvas link is the first Cursor surface shaped exactly like that decision: open the link, read the board, decide. No repo, no diff, and no IDE sits between the finished result and the person approving it.

    The lane question the feature raises is a seat question. What reaches Stefani and Ziggy today is finished artifacts — live pages, PDFs, one-line summaries — because they work outside the operator’s seat. A canvas would be the cheapest of those artifacts to produce and the easiest to read, if the recipients hold team seats. The docs make team membership the door, so who holds a seat becomes a setup decision to make on purpose — not an assumption to discover after a link bounces off someone it was meant for.

    What is not established, labeled plainly: our production lane launches cloud agents over the API and receives text back. The docs describe canvases in the app surfaces — the Agents Window, the canvas toolbar, the dashboard. Whether a run launched through the API can produce a canvas, or return a share link, is not in the docs we read and not in our records. That question goes on the check list. It does not go into the workflow.

    One more mapping, labeled as intent rather than record. The docs say common canvas workflows can be packaged as skills, so every run that uses the skill returns the same output shape. In this shop’s language, that is a debrief template: the same board for every fleet run — what was asked, what landed, what the counts say, what failed. A debrief-canvas skill is the first experiment this change earns here. It has not run yet.

    Our record, stated plainly

    No canvas has appeared in our runs yet. Our run record — every cloud agent this desk has launched, reconciled from the API and watched daily — contains no canvas artifact and no share link as of October 19, 2026. The only “canvas” in that record is an agent named for a Google Maps canvas, a different sense of the word, and a standing reminder to grep carefully before claiming a first.

    So this piece is a map, written before the landing: what the feature is on the vendor’s own pages, what its gates are, and where it would sit in a loop that already exists. The check is decided. The next data-heavy Desktop sitting asks for its debrief as a canvas, by name, and the canvas gets read against the same sitting’s transcript — the surface we trust — before the desk adopts it anywhere. If the board and the record disagree, the record wins, and the disagreement gets written down on this page with a date.

    Method & settings — this piece

    Sources: Cursor changelog, entry dated October 16, 2026; Cursor Docs, “Canvases” (read October 19, 2026). Vendor facts are stated as the vendor’s; the secondary write-ups that surfaced this item were used as leads only, never as sources

    Our surfaces in this mapping: Desktop 3.25.9 on the laptop (read from the install itself, October 19, 2026); cloud agents over the API (model catalog baseline 46 models, October 16, 2026)

    Our canvas record: none — no canvas artifact or share link in our run record as of October 19, 2026. This is a mapping piece, not a hands-on report

    Desk rule: every fact carries its provenance and date — our record, or Cursor’s page, never blended

    Filed under the Cursor desk — the desk that runs Cursor as a production harness.

  • Meta Model API Pricing & Limits: Wonder, Spark, and the Cheap Tier That Trains on You

    Meta Model API Pricing & Limits: Wonder, Spark, and the Cheap Tier That Trains on You

    From the Tygart Media Meta desk. Prices below are Meta’s published rates, verified against Meta’s own pricing documentation on November 5, 2026, and cross-checked against our account’s live catalog on November 5, 2026. This page is the desk’s drift-watch surface: when Meta moves a number, this page is where the change gets recorded, dated. Desk home: Meta AI, Run in the Open.

    Meta’s pricing has one genuinely simple story and one trap. The simple story: a flagship priced exactly at the market’s flagship rate, a workhorse priced like a workhorse, both with million-token context and no long-context surcharge. The trap is a third tier that costs about 95% less — because you’re paying with your data instead. Here is the whole map, with the trap labeled.

    The API tiers (per million tokens)

    Model Input Cached input Output Rate limits (per team)
    Muse Wonder $4.00 $0.20 $20.00 3,000 RPM / 4M TPM
    Muse Spark 1.3 / 1.2 / 1.1 (Standard) $1.25 $0.15 $4.25 3,000 RPM / 4M TPM
    Muse Spark Contributor $0.10 $0.002 $0.20 150 RPM / 3M TPM

    Wonder’s $4/$20 matches the going flagship rate dollar for dollar — Meta is not discounting its best model, it’s daring you to compare it. Spark at $1.25/$4.25 is the tier a working shop will actually live on: a quarter of the flagship’s input price and under a quarter of its output price, with the same 1M-token context window and the same rate limits. There is no long-context premium at any length, which quietly removes a whole category of surprise bill. Web-search grounding, if you use Meta’s built-in tool, is $2.50 per 1,000 queries on top.

    The rest of the catalog is priced like utilities: Muse Image generates at a flat $0.01 an image, Voice Transcribe runs $0.18 per audio hour with diarization, and the SAM 3.1 segmentation model is $2.50 per 1,000 images — all three confirmed in our own account census on October 14, 2026. Spark’s maximum output is 131,072 tokens; Wonder’s maximum output is not stated on the pages Meta publishes, and this page won’t guess it.

    The Contributor trap: cheap because it trains on you

    Read the Contributor tier’s price again: $0.10 in, $0.20 out. That is not a sale. Meta’s own pricing page is plain about the exchange — in Contributor mode, Meta may use your prompts and the model’s completions to improve and train its products. Your discount is paid in data. Standard mode, at the prices in the table above, is the mode where your content is not used for training.

    Our house rule, printed so our future selves can’t negotiate with it: Contributor tiers are for disposable experiments only — never for client work, never for unpublished material, never for anything you wouldn’t read aloud in Meta’s lobby. The arithmetic isn’t close. A shop that routes real work through Contributor to save $4 a million tokens is selling its clients’ material at a price it would never accept in a contract. And one more wrinkle worth knowing: Muse Code subscriptions default to Contributor mode unless you turn it off — so the trap is also a default, and defaults are where shops actually live.

    The Cursor split: Spark is in, Wonder is out

    If your shop runs Cursor, your Meta options today are exactly one model long. Muse Spark 1.3 is a first-class Cursor model — added September 8, 2026, about six days after the model itself shipped — at the same $1.25/$4.25 rates, with full access to Cursor’s agent tools, a 300k context window by default or the full 1M in Max Mode. Muse Wonder is not in Cursor at all: no model page, no changelog entry, no announced timeline, and Cursor’s official bring-your-own-key program covers five providers — Meta is not among them. The base-URL override workaround exists, but Cursor staff describe it as unsupported and partially broken, it applies globally while it’s on, and it can never bring you Wonder Full. Bottom line from a shop that checked: for Meta inside Cursor, run native Spark 1.3; for Wonder, use the API.

    Muse Code plans — reported, not verified by us

    Meta’s own terminal agent, Muse Code, is sold by subscription as an alternative to per-token billing. The plan structure is verified on Meta’s documentation: four tiers — Everyday, High, Power, Maximum — with Power and Maximum including Wonder Full, the stronger flagship variant that the API does not sell at any price. The dollar figures below come from secondary reproductions of Meta’s pages, and we label them reported because we have not paid one yet: Everyday $5/month, High $15/month (5×), Power $50/month (20×), Maximum $200/month (80×). When this shop runs Muse Code through a real sitting, this section gets rewritten from receipts. Until then, it stays labeled.

    What the numbers don’t tell you

    Two costs never appear on a pricing page. The first is token hunger: independent launch-week measurement found Wonder slower to first token than its rivals’ median and thirstier with output tokens, and in an agent loop — where a model may be called hundreds of times on one job — a thirsty model at a fair per-token price can still be the expensive seat. The second is your own switching cost, which Meta has unusually lowered: one key speaking OpenAI and Anthropic protocols means the harness you already run is the harness you evaluate with. Our proof of that, and the gotcha that came with it, is in The Meta Model API, As We Run It.

    Last verified: November 5, 2026. The desk’s catalog watch re-reads Meta’s model list daily; pricing drift gets recorded here with its date, the same discipline this site applies to Claude’s pricing.

  • The Meta Model API, As We Run It

    The Meta Model API, As We Run It

    From the Tygart Media Meta desk — our own API key, our own test envelope, our own receipts. Desk home: Meta AI, Run in the Open.

    Every vendor will sell you an API with a launch post. What a working shop needs is duller and more valuable: does it answer, does it finish real work, what does it cost to find out, and what stupid thing will eat your first afternoon? On October 14, 2026, we wired Meta’s Model API into our own tooling and ran it. Here is the whole story, including the part where we blamed the API for our own mistake.

    The setup: one key, stored like it matters

    Meta’s developer platform is dev.meta.ai. You make a key in the dashboard, you put it in a vault — ours lives in our credential store, injected into the process only at run time, never written to disk, never pasted into a chat. Billing rides a partner-controlled card with a hard $25 test envelope on it. That envelope is a deliberate choice: a new platform earns production trust in stages, and stage one is “prove it works for pocket change.”

    The first check cost nothing: list the models. Our key read Meta’s catalog clean — nine models, from Muse Wonder down to a segmentation model we still haven’t touched. A key that can read the catalog is a key that works; everything after that is about the work, not the wiring.

    The proof: a work-order-shaped task, 52 seconds

    We pointed OpenCode — an open-source terminal agent, version 1.19.0 — at Meta’s API as an OpenAI-compatible provider, and handed Muse Spark 1.3 the kind of job this shop hands every seat: a written spec (SPEC.md), from which it had to produce a working Python module (a slug utility) plus a pytest suite covering it. Not a riddle, not a benchmark — a small, real, verifiable unit of work with a pass/fail at the end.

    Spark 1.3 finished in about 52 seconds. Mid-run it discovered pytest wasn’t installed in its environment, provisioned its own virtual environment, installed what it needed, and ran its tests: 8 of 8 passing. Then we did what we do with every seat’s output, including our own: we didn’t take its word. We re-ran the suite ourselves, added five extra cases of our own, read the code line by line. All green, code clean. Total damage to the $25 envelope across the entire day’s probing of every text model on the account: under two cents.

    The gotcha: our first failure was not Meta’s

    The first attempt “failed.” Silently. No error, no output — the run simply never came back. The natural conclusion is that the shiny new API is broken. The actual cause: opencode run hangs forever when its standard input is left open in a non-terminal session. Run it with stdin closed — </dev/null — and it works perfectly. No API fault, no key fault; a harness quirk that cost us one debugging cycle and taught us, again, the oldest lesson in this shop: when a new platform “fails,” check your own plumbing before you write the platform off. We’re printing the gotcha in the desk’s first article on purpose. The next shop that wires this API deserves to skip our lost afternoon.

    One API, three dialects — and why a shop should care

    The most consequential thing about Meta’s API is not any single model. It’s that the same key speaks three protocols: OpenAI’s Chat Completions, OpenAI’s Responses API, and Anthropic’s Messages API. Meta’s own quickstart documents pointing Claude Code at api.meta.ai by changing a base URL, Codex at the Responses surface, and OpenCode at the OpenAI-compatible endpoint — all with the one key.

    For a shop, that collapses a real cost. Harnesses are habits: your prompts, your permissions, your work-order formats, your muscle memory. A model provider that demands a new harness taxes every one of those. A provider that plugs into the harness you already run lets you spend your evaluation budget on the only question that matters — is the model any good at your work? It’s also a discipline on the provider: when switching is cheap, the model has to win on merit every month, not on lock-in. We like platforms that volunteer for that test.

    Two quirks worth knowing before your first loop. Reasoning is mandatory on these models: settings like reasoning_effort: "none" come back as errors rather than being quietly ignored, so sloppy OpenAI drop-in code can fail loudly — better than silently, but plan for it. And reasoning tokens burn against your output cap, so set generous maximums; a tight cap buys you empty replies, as our census probes found out so yours don’t have to.

    What this does not prove — yet

    One 52-second task proves the route works and the model can finish a small job cleanly. It does not prove Wonder’s ceiling, anyone’s reliability across a month of autonomous loops, or behavior under production load — and this desk won’t claim otherwise. The head-to-head that would actually settle the seat question — Composer vs. Spark in Cursor vs. Wonder through this API, same work order, same scoring — is scheduled and unrun, and it’s named that way on the desk’s front page. When it runs, it lands here, numbers and all, whichever way it cuts.

    Prices, tiers, and the one discount that should make you read the fine print twice are on the desk’s pricing page: Meta Model API Pricing & Limits.