Guides

Usage patterns

• Add a critic, not a committee Shared methods

  One independent critic measurably improves agent work. A panel of role-play agents mostly agrees with itself, at several times the cost.

• Ask for three options, not one answer Shared methods

  The first answer is one draw from a distribution, delivered with full confidence. Asking for alternatives shows you the spread before you commit.

• Ask what it assumed Shared methods

  Every answer to an underspecified question rests on assumptions the model filled in silently. One follow-up makes them visible while they are cheap.

• Attach the file you are describing Shared methods

  Summarising a document from memory feeds the model your summary's errors. If the file exists, the file goes in — your description was the lossy copy.

• Chat is not always the right tool Shared methods

  Some jobs fit a chat window; some need search, a file upload, an agent, or a spreadsheet. Matching job to mode is a two-question decision.

• Check it before you act on it Shared methods

  Confident and correct look identical in a model's answer. Before a fact changes what you do, make it show its evidence — or look it up once.

• Don't do arithmetic in prose Shared methods

  A language model predicts text, and sums are text it can get plausibly wrong. Make it compute — with a table, code, or an analysis tool — or check the number yourself.

• Don't fan out past your review capacity Shared methods

  Agents multiply what gets produced; nothing multiplies what you can actually read. The ceiling on useful parallelism is your review throughput.

• Don't forward what you haven't read Shared methods

  Polished, substance-free AI output has a name now — workslop — and a documented cost: the work you skipped lands on whoever receives it.

• For current facts, make it search Shared methods

  Prices, versions, deadlines and news drift past a model's training data. Asking without search gets you a confident answer from last year.

• It does not remember your last chat Shared methods

  "As we discussed yesterday" refers to a conversation the model cannot see. It will play along anyway — that is the dangerous part.

• It only knows what you paste Shared methods

  The model has not seen your document, your thread, or your last attempt unless they are in the conversation. Most "bad answers" are missing inputs.

• Let it interview you first Shared methods

  You know things about your problem that you don't know are relevant. One instruction turns the model from guesser into interviewer.

• Make it argue the other side Shared methods

  A model agrees with your framing by default. Asking for the strongest case against is the cheapest second opinion you will ever get.

• Make the next rewrite more useful Shared methods

  Three rewrites without saying what was wrong is a slot machine, not editing. Name the gap, or start fresh — repeating "again" does neither.

• More context is not better context Shared methods

  Pasting everything you have buries the part that matters. Curate what goes in, and say which part the answer should lean on.

• One request, five tasks Shared methods

  A prompt doing five jobs gets five mediocre answers stapled together. Split it, and each step gets the model's full attention plus your checkpoint.

• Paste the exact error, not your summary of it Shared methods

  "It doesn't work" starts a guessing game. The exact message, or a screenshot, starts a diagnosis — the difference is one paste.

• Raise the checking with the stakes Shared methods

  The same answer deserves a skim when it names a restaurant and a real verification when it names a medication dose. Scale the check to the cost of being wrong.

• Say what you actually want Shared methods

  "Make me a plan" produces the average plan for the average person. Name the outcome, and the answer starts being about your situation.

• Show one example instead of three adjectives Shared methods

  "Professional but warm" means something different to everyone, including the model. One example of what you want outweighs a paragraph describing it.

• Stop hitting the limit mid-task Shared methods

  Running dry in the middle of real work is a planning failure with a planning fix: know the window, spend it deliberately, park state before the cliff.

• Stop re-explaining your project Shared methods

  Typing the same background into every chat is a tax. Put the stable facts somewhere persistent once, and every conversation starts warm.

• Tell it what "better" means Shared methods

  "Make it better" makes it different. Naming the dimension — shorter, warmer, simpler — is what makes it better in the way you meant.

• That data belongs to someone else Shared methods

  Your colleague's appraisal, a customer's complaint, your friend's medical story — pasting it is a decision about their data that only you were present for.

• That paste contains a secret Shared methods

  Passwords, API keys and other credentials have no safe form inside a prompt. Redact before pasting — the model never needed the real value.

• The agent passed the check by changing the check Shared methods

  Give an agent a test to satisfy and sometimes it satisfies the test instead of the task — editing it, deleting it, or stubbing the code the test needed.

• The big model is not for everything Shared methods

  Running the flagship on trivial questions spends the quota you will want for the hard ones. Match the model to the task, not to habit.

• The context you never trim Shared methods

  A session whose context only ever grows pays for its whole history on every turn. Compact at natural breakpoints, or start fresh with a summary.

• The plan file stopped being true Shared methods

  A written plan is only an asset while it matches reality. Code moves, the spec sits still, and an agent will happily follow the stale version.

• This conversation is past its best Shared methods

  Long chats accumulate dead weight: rejected drafts, stale constraints, old errors. When steering stops working, a fresh start beats another correction.

• You are about to use something you have not read Shared methods

  Sending, running or filing an output you only skimmed makes its errors yours. The read costs minutes; owning an unread error costs more.

• You are doing work it could structure Shared methods

  Copying fifteen rows by hand, reformatting the third similar document, renaming files one by one — repetition with a rule is the model's home turf.

• You are the copy-paste middleware Shared methods

  Shuttling text between the chat and your apps, piece by piece, is a job the tools can do. If you moved the same kind of thing three times, stop.

Foundations

How these systems actually work, without the hand-waving.

• Chat, Projects, Cowork or Code: picking the right mode Claude + Cowork + Claude Code

  Four surfaces, four cost profiles. Picking wrong is the most common reason people burn an allowance on work that did not need it.

• Decide when to continue or start fresh Shared methods

  Preserve coherent progress, recognize repeated failed approaches, and transfer the evidence needed for a useful restart.

• Examples beat adjectives: showing instead of describing Shared methods

  "Conversational but authoritative" means something different to everyone, including the model. Three to five examples pin down what adjectives cannot.

• Give the task sufficient, current context Shared methods

  Choose relevant original evidence, retain its source and revision, and add more context when the task shows it is needed.

• Thinking, reasoning and "effort" — what these controls do Anthropic API

  Thinking is billed output you mostly never read. The control moved from a token budget to an effort level, and on current models the old one errors.

• Tokens: why cost and quota do not track word count Shared methods

  The unit everything is billed and rationed in. It is not words, and the gap between the two is where people's mental arithmetic goes wrong.

• Understand the working context Shared methods

  Distinguish a model's working input from stored files, retrieval, compaction, memory, and cumulative usage.

• What these systems are structurally bad at Shared methods

  Five limits that follow from how the thing is built, so they do not go away with a better prompt or a newer model. Plan around them.

• Why the same prompt gives different answers Shared methods

  Sampling makes the output vary by design, and on current models there is no setting that turns it off. The skill is designing work that survives it.

• Writing a prompt that survives a long task Shared methods

  A prompt that works for one answer often collapses over twenty turns. What survives is self-contained, names what is out of scope, and ends with a check.

Everyday Claude

Chat, Projects, memory, files, plans and limits.

• Artifacts: turning a conversation into something you can use Claude

  A described idea becomes a working app in the side panel. The skill is the same as ever — iterate deliberately, and break it before you share it.

• Connectors: what you hand over when you connect Drive Claude

  A connector inherits your access, so its reach equals yours. That is the security model and the risk in one sentence.

• Emotional and wellbeing use: what it is and is not for Shared methods

  The APA's position is qualified, not absolute: a supportive adjunct to care, never a replacement for it. Here is where the line actually falls.

• Files, images and PDFs: what actually gets read Claude

  A PDF over 100 pages has its text read and its charts ignored, silently. Knowing what is extracted from what saves you trusting an answer built on half a document.

• Getting your data out Claude

  Export lives in Settings, Privacy, arrives by email and expires in 24 hours. Conversations come out but cannot go into another personal account.

• Memory across chats: what persists and what does not Claude

  Memory is a separate store of topics that gets re-injected into new conversations. It is not the model recalling you, and it is editable.

• Projects: what belongs in one, what poisons it Claude

  Project knowledge is shared across every chat in the project. Past a size threshold it quietly stops being read whole and starts being searched.

• The training toggle, retention, and what you agreed to Claude

  Consumer and commercial plans have different rules. Most people do not know which one they are on, and the difference is measured in years.

• Using it as an accessibility tool, and its blind spots Claude

  Genuinely useful as assistive technology, with one structural catch: the person relying on the output is often the one who cannot check it.

• Voice, mobile and desktop: same Claude, different affordances Claude

  The model does not change between surfaces; what you can feed it and check does. Pick the surface by the task's input and its review needs.

• Web search and citations: reading past the summary Claude

  A citation proves a page was retrieved. It does not prove the page says what the sentence attached to it claims.

• Which plan, honestly Claude

  How to tell which tier you actually need, and the two situations where upgrading does not fix the thing you are upgrading to fix.

• You hit a limit. Now what. Shared methods

  Six things that are faster than waiting, in the order worth trying them — and how to stop arriving here every week.

Developing with ChatGPT

Reason from code and sources, maintain context, and return checked artifacts.

• Apps and plugins: what ChatGPT may read and what it may do ChatGPT

  Reading is granted by default. Actions are gated by a risk judgement ChatGPT makes per request, and the default differs depending on which plan your workspace is on.

• Build a technical decision from traceable sources ChatGPT

  Turn a bounded research question into a decision brief whose claims, tradeoffs, and missing evidence can be inspected.

• Keep a development brief in a ChatGPT project ChatGPT

  Maintain the facts that should survive a new chat, and verify that the right sources are being used.

• Model training, deletion, and the thirty-day window ChatGPT

  One toggle decides whether your chats train future models. A separate set of rules decides how long anything survives after you delete it, and files do not follow the same rules as chats.

• Turn code and logs into a useful diagnosis ChatGPT

  Give ChatGPT a small evidence packet, separate observed facts from guesses, and leave with a patch or a precise handoff.

• Uploading files: the limits that decide what gets read ChatGPT

  A file can be well under the size limit and still be truncated, because the binding constraint is a token cap rather than megabytes. Storage is shared across chats, projects and custom GPTs.

• Use ChatGPT to analyze CI metrics you can reproduce ChatGPT

  Inspect the input, define the comparison, and return calculations and a report that another developer can check.

• Web search: the query it ran was not the one you typed ChatGPT

  ChatGPT rewrites your question into targeted queries and sends them to search partners. The inline citations are a subset of what it consulted, and the vendor tells you to open them.

• What ChatGPT remembers, and what it takes to remove something ChatGPT

  Memory is assembled from your chats, files and connected apps. The summary you can read is not the whole of it, and deleting one entry is not how you get something out.

• Which ChatGPT plan, honestly ChatGPT

  The tiers are ordered by how much you may use, measured in a rolling window. Working out where you sit takes a week of observation and beats every comparison table.

Developing with Gemini

Engineering briefs, Gems, and research with selected sources.

• Activity, retention, and the review copy that outlives deletion Gemini

  Gemini keeps activity for eighteen months by default. The number worth knowing is a different one: reviewed conversations are held for up to three years and deleting your activity does not reach them.

• Connected Apps: what 'we don't train on your inbox' actually covers Gemini

  Google is precise that it does not train directly on your Gmail or Drive. The sentence after that one is the important sentence, and it points back at a setting you may already have on.

• Research a technical decision with selected Gemini sources Gemini

  Review the research scope before starting, trace the decision-driving claims, and preserve evidence after export.

• Sources in Gemini: related to the answer, not proof of it Gemini

  Google's wording is that source links may be related to parts of a response. A source can also be your own uploaded file, and code citations can carry a licence you are now responsible for.

• Uploading files and a whole repository to Gemini Gemini

  Gemini takes a code folder or a GitHub repository as one attachment, up to five thousand files. What it does with the contents is documented less well than the limits are.

• Use a Gemini Gem for recurring engineering reviews Gemini

  Turn a maintained engineering brief into a reusable review, with explicit evidence and unresolved questions.

• What Gemini remembers, and the accounts where it does not Gemini

  Memory of past chats is a personal-account feature tied to the same setting that governs retention. On a work or school account it is absent, which is the fact worth planning around.

• Which Gemini plan, honestly Gemini

  Google sells AI access and cloud storage in the same subscription, so the tier that fits your Gemini use and the tier that fits your Drive are often not the same one.

Claude Code

The terminal agent, for people who ship software.

• A CLAUDE.md that actually gets followed Claude Code

  It is read every session, so every line is a recurring cost. Facts belong here; procedures belong in a skill.

• Git hygiene with an agent in the loop Claude Code

  Checkpoints look like undo and have five documented holes, including anything done by a bash command. Git is what covers them.

• Hooks: the part of the loop the model cannot skip Claude Code

  Instructions are requests a model probably honours. A hook is code that runs at a lifecycle point whether the model would have chosen to or not.

• Large refactors: scoping work an agent can hold Claude Code

  The unit of work is however much fits in one window with room to think. Size for that, and the refactor becomes a series of small verified changes.

• MCP servers: when they are worth it Claude Code

  Connect one when you keep pasting from the same tool. Reach for a CLI first, because Anthropic calls that the most context-efficient option there is.

• Permissions: allow, gate, deny Shared methods

  Decide the posture once, deliberately. Approving prompts reflexively for a week is also a decision, made badly and by accumulation.

• Plan first, execute second Shared methods

  A cheap planning pass prevents an expensive execution pass in the wrong direction, which is the most costly thing an agentic session can do.

• Plugins and marketplaces: what installing actually adds Claude Code

  One install can add skills, agents, hooks and MCP servers at once. Know what arrived, what it costs at startup, and how to walk it back.

• Quota discipline in an agentic loop Shared methods

  An agent that reads a lot spends a lot. Six habits that cut consumption without making the work worse.

• Reviewing what the agent wrote Claude Code

  You are reviewing a diff whose author cannot tell you what it was unsure of. Read for the things it never flagged, and let a fresh context do the first pass.

• Secrets, credentials, and what never enters context Claude Code

  Four routes get a secret into the transcript, and a Read deny rule closes two of them. Only the sandbox stops a script that opens the file itself.

• Skills, and when to write one Claude Code

  A skill is a procedure loaded only when it is relevant. Write one when you keep pasting the same instructions — and not before.

• Slash commands, and the prompt you keep retyping Claude Code

  Any prompt you have typed three times is a file waiting to exist. The modern mechanics: commands and skills are one system, invoked with a slash.

• Subagents: delegating without losing the thread Claude Code

  A subagent reads in its own context and returns only a summary, so the investigation costs you a paragraph instead of thirty files.

• The first hour with Claude Code Claude Code

  What to do, in order, so the first session teaches you something useful rather than either disappointing you or impressing you into overconfidence.

• Use Claude Code in a repeatable pipeline Claude Code

  Separate JSON transport, permissions, authentication, and human decisions when automating a Claude Code task.

• Why context management is most of the skill Claude Code

  Anthropic says most of their own best practices descend from one constraint. Knowing what each action costs turns that from advice into arithmetic.

• Working in a repo you do not know Claude Code

  The model reads faster than you, which changes what the first hour is for. Interrogate before you change, and let the plan expose what you both missed.

• Worktrees: running sessions that cannot step on each other Claude Code

  A worktree gives a session its own checkout, so two agents never fight over the same files. The cost is a fresh directory that has none of your setup yet.

Working with Codex

From a clear task to a checked change, with reusable instructions and skills.

• Choose Codex planning and reasoning around the task Codex

  Use planning for real decisions, inspect the available reasoning controls, and finish with evidence of the changed behavior.

• Codex: from a task to a reviewed change Codex

  Give Codex a real task, keep project rules in AGENTS.md, and turn a proven routine into a skill. Finish with evidence you can review.

• Give Codex project rules and reusable skills Codex

  Check instruction discovery, keep AGENTS.md concise, and package a routine only after it works.

• Know where Codex runs and which account supplies access Codex

  Distinguish the checkout, execution environment, hosting interface, and authentication method before relying on a result.

• MCP servers in Codex: when they are worth it Codex

  A server is a standing connection that holds credentials and decides when to use them. Codex can drive most tools through their command line first, which costs nothing to install and nothing to trust.

• Use Codex in a repeatable pipeline Codex

  Run a bounded Codex task, validate its final output, and hand the result to a coordinator with explicit human decisions.

Working with Gemini CLI

Repository context, planning, checked changes, and programmatic use.

• Make a checked repository change with Gemini CLI Gemini CLI

  Inspect loaded instructions, review a concrete plan, implement in the intended checkout, and verify the original failure.

• MCP servers in Gemini CLI: when they are worth it Gemini CLI

  Gemini CLI connects servers from a settings file, gates their tools through the policy engine, and can pull a server's resources straight into context. Each of those is a decision, and the first one may have been made by whoever wrote the repository.

• Use Gemini CLI in a repeatable pipeline Gemini CLI

  Validate Gemini CLI's inner response, configure headless permissions explicitly, and retain human gates in the coordinator.

Cowork

An agent working across your own files and connectors.

• Choosing what it may see: folders, connectors, and the screen Cowork

  Three separate grants, three separate decisions. Most people make the first one carefully and the other two by accident.

• Cloud or local execution — what actually changes Cowork

  Where the agent loop runs decides whether your machine has to stay awake, where your files get processed, and what your admin can see.

• Computer use: no sandbox, per-app permissions, the blocklist Cowork

  A categorically different grant from the built-in browser. Anthropic's own words: no sandbox between Claude and your applications.

• Cowork on mobile: steering from away Cowork

  The phone is a good remote control for an agent and a poor cockpit. Start and redirect from anywhere; keep the heavy work where the files and review are.

• Parallel chunks: when splitting helps and when it fragments Cowork

  You do not choose the split. Cowork decides, automatically, and what you actually control is the goal that makes a good split possible.

• Reading the step trail: files opened, tools used, decisions made Cowork

  Learn what a healthy run looks like while nothing is at stake, so you can recognise an unhealthy one when something is.

• Reviewing agent output you did not watch being made Cowork

  The output looks the same whether it is right or wrong. Review the joins, the edges, and the things it did not say.

• Scheduled and recurring tasks Cowork

  Tell it once and it runs on a schedule. Which means a grant you made in January is still acting in June, on inputs nobody reviewed.

• The built-in browser: forms, logins, and what not to let it near Cowork

  Every page it opens is untrusted input. Prompt injection is not a theoretical risk here; it is the expected one.

• Undo, blast radius, and working on copies Cowork

  Cowork has no documented undo. Deletion asks permission; editing does not. Decide what it can reach before you start, not after.

• What Cowork is, and how it differs from a chat Cowork

  A chat answers you. Cowork goes and does the work — across your files, your connected tools, and optionally your actual screen.

• When it runs unattended: what to set up first Cowork

  Walking away removes the only control most people rely on. Five things to settle before you do, starting with where the task actually runs.

• Writing a goal an agent can actually finish Cowork

  Describe the finished state and what must not happen. Leave the method alone — and say what to do with the cases that do not fit.

• Your first Cowork task Cowork

  Pick something multi-step, real, and cheap to get wrong. Fifteen minutes, on a copy.

Anthropic API

API, agents, tools and MCP.

• Agent SDK, Managed Agents, or the raw API Anthropic API

  Four ways to build on Claude, separated by one question: who runs the agent loop and the sandbox. Answer that and the choice mostly makes itself.

• Batching and cost control Anthropic API

  Half price for work that can wait an hour. The catch is a hard 24-hour expiry, and it is the only cost lever that needs no prompt changes.

• Building an MCP server: exposing your thing to the model Anthropic API

  A server is a small adapter between the model and something you own. The hard parts are not the protocol; they are the trust boundary you just opened.

• Choosing a model Anthropic API

  Start at the default, move only for a reason, and match the tier to the step rather than to the project.

• Context editing, compaction, or memory Anthropic API

  Three mechanisms for a conversation that outgrows its window. One clears, one summarises, one stores — and they compose rather than compete.

• Do you actually need an agent? Anthropic API

  Anthropic's own advice is to find the simplest thing that works, which "might mean not building agentic systems at all". Usually one call is enough.

• Error handling that distinguishes retryable from not Anthropic API

  A 529 deserves a retry, a 400 never earns one. Sorting the API's errors into those two bins is most of production error handling.

• Evaluating an agent: what "working" means Anthropic API

  Anthropic's own advice is volume over polish: more cases graded roughly beats few graded well. For an agent, grade the trajectory and not only the answer.

• Migrating to a newer model Anthropic API

  A model swap is not a string change. Parameters break loudly, behaviour changes quietly, and the quiet half is where migrations actually fail.

• Prompt caching that actually hits Anthropic API

  Reads cost a tenth of normal input, so caching pays from the second request. A prompt under the minimum is silently not cached, with no error.

• Streaming and long turns: the 200 is not the finish line Anthropic API

  Streaming trades one big wait for many small events, and moves failure to after the response starts. The event flow and the mid-stream error are the two things to get right.

• Structured output Anthropic API

  Guaranteed-valid JSON is not guaranteed-valid data. Half your schema is stripped before the model ever sees it, and your code enforces the rest.

• Tool use without the common foot-guns Anthropic API

  Ask for the weather with no city and it may invent one, plus a unit you never asked about. Four failures that are cheap to prevent and expensive to debug.

• Writing a tool description a model can use Anthropic API

  Anthropic calls the description "by far the most important factor in tool performance". Most are one line long. Aim for three to four sentences.

OpenAI API

Bounded model calls, structured artifacts, and explicit access.

• Return a checked artifact with the OpenAI API OpenAI API

  Use a closed output schema, validate completion and evidence, and keep model output separate from pipeline authority.

Gemini API

Direct model calls and validated handoffs for your own programs.

• Return a checked artifact with the Gemini API Gemini API

  Choose an explicit API response family, constrain the task output, and validate source evidence before the next stage.

Trust and honest value

Whether to believe the output, and whether it is really helping.

• Automation bias: the failure mode of trusting a good tool Shared methods

  The better the tool gets, the less you check it. The EU AI Act names this by its research name and obliges people to stay aware of it.

• Deskilling: keeping the judgement you are delegating Shared methods

  Delegating work is fine. Delegating the judgement that checks the work is how you lose the ability to notice when the work is wrong.

• Does it actually make you faster? Shared methods

  The best measurement we have found experienced developers were slower with AI, while believing they were faster. Both halves matter.

• Explaining to someone else why the output is wrong Shared methods

  Rejecting AI output is easy alone and hard in a meeting. The words that work attack the claim, not the tool, and put the burden where it belongs.

• Verifying output you are not qualified to check Shared methods

  You cannot review an answer in a field you do not know. You can check whether it is internally consistent, externally corroborated, and willing to be wrong.

• When to not use it at all Shared methods

  Five situations where the honest answer is to close the tab. A help site that never says this is selling something.

• Why AI can invent convincing details Shared methods

  Understand why plausible text can be false, how evaluation incentives matter, and how to verify technical claims.

Security

Prompt injection, agent permissions, blast radius.

• Confused deputy: your agent, spending your authority Shared methods

  An agent holding your grants is the most deputy-shaped software ever built. The attack is not stealing its credentials, it is asking it nicely to use them.

• Data exfiltration through an agent's own tools Claude Code

  An agent that can read files and reach the network is already a channel. The control is egress, because detection is the part that cannot be relied on.

• Incident response when an agent did something Claude + Cowork + Claude Code

  The playbook assumes a human actor and an agent breaks its first three questions. Decide before the incident what your records will be able to say.

• Limit what an agent can read, change, and send Shared methods

  Choose an execution boundary for the actual tool and host, keep credentials separate, and place human decisions before consequential actions.

• MCP servers: what you install when you install one Shared methods

  An MCP server is credential-level access with no signing and no review. The NSA has published guidance on it, which tells you how real this is.

• Prompt injection, explained without jargon Shared methods

  Instructions hidden in content your AI reads. No failsafe defence exists today, so the work is containing what one could accomplish.

• The OWASP agentic threats, in plain language Shared methods

  OWASP's agentic threat model names fifteen-plus ways an agent gets turned against you. Most map onto pages you have already read; this is that map.

• The OWASP LLM Top 10, in plain language Shared methods

  Ten named risks, translated out of security vocabulary. Most of them are pages on this site already; this is the map between the two.

• Vetting a skill before you install it Shared methods

  Across 31,132 published skills, 26.1% carried at least one vulnerability. They are not signed, and they steer an agent that already holds your files.

• What never goes in a prompt Shared methods

  A short absolute list, and the reasoning that makes it stick better than a long list of prohibitions nobody remembers.

Business and governance

Rollout, data rules, the AI Act, works councils.

• Admin controls: what you can actually govern Claude

  The settings that exist, the defaults that differ between Team and Enterprise, and the gap where local sessions sit outside central control.

• AI governance frameworks: which one, if you must pick Shared methods

  NIST AI RMF and ISO/IEC 42001 are not rivals. One is a free way to think, the other a paid way to prove — pick by whether you need a certificate.

• An acceptable-use policy you can actually edit Shared methods

  A short template to adapt, with notes on why each clause is there and which ones are usually wrong for a smaller organisation.

• Disclosure: when to say a machine was involved Shared methods

  Some contexts require it and have settled rules. Most do not. A workable test, and where the established norms already exist.

• Measure outcomes alongside AI adoption Shared methods

  Distinguish usage, reliance, and value, and compare complete developer tasks instead of treating message volume as productivity.

• Rolling out AI without a policy vacuum Shared methods

  People are already using it. The question is whether they are doing so on accounts you chose, under terms you read.

• Seats, plans and quota planning for a team Shared methods

  Usage is uneven enough that averages mislead. Size from a pilot, and expect a handful of people to account for most of the consumption.

• The AI Act calendar, and which side of it you are on Shared methods

  Transparency obligations under Article 50 came into force on 2 August 2026. Most organisations are deployers, and that changes which dates apply.

• The EU AI Act in fifteen minutes Shared methods

  A risk-based law, not a technology law. Four tiers, and most people using these tools sit in the lowest one with two obligations that still apply.

• The EU AI Act's AI literacy obligation, practically Shared methods

  In force since 2 February 2025. It covers your contractors too, no format is mandated, and the standard is proportionate rather than absolute.

• Vendor questions: retention, processing and audit Shared methods

  The questions worth asking any AI vendor, and what a good answer looks like. Written as questions because the answers change and yours may differ.

• What data may go into a model Shared methods

  A classification scheme you can adopt, and the terms difference that most policies get wrong: consumer plans and commercial plans are not the same deal.

By context

Assembled playbooks for students, teams, regulated work.

• A developer team's path through the guide Shared methods

  Choose product-specific onboarding, standardize evidence and access, and evaluate workflows against a measured baseline.

• Designers: exploration is cheap now, and ownership got complicated Shared methods

  Generating fifty directions before lunch is real. Whether anyone owns the one the client picks is the question the profession has not priced in yet.

• Healthcare-adjacent work: clerical or clinical Shared methods

  WHO's guidance draws one usable line: administrative relief is the real win, and anything touching a clinical decision goes through governance, not chat.

• Lawyers and regulated professions: the duties did not move Shared methods

  No rule of professional conduct changed. The tools created new ways to breach the old ones, and one judge wrote down exactly how in a sanctions order.

• Non-profits: capacity you could not afford, trust you cannot spend Shared methods

  The tools fit the sector's oldest constraint, too much mission per person. The catch is that a charity's currency is trust, and beneficiary data is not the charity's to risk.

• Public sector: authority, records, and the citizen who cannot opt out Shared methods

  Government use differs in kind, not degree. Your outputs carry state authority, your citizens cannot choose a competitor, and your files are records.

• Researchers and authorship: the settled rule and the unsettled rest Shared methods

  ICMJE's position is precise: an AI cannot be an author because it cannot be accountable. What you must disclose, where, and what stays yours to verify.

• Small businesses and sole traders Shared methods

  Most governance advice assumes an IT department. Here is the same material for one person who is the admin, the user and the data controller at once.

• Students: using it without cheating yourself Shared methods

  "Don't use it" is not advice anyone follows. The real question is which uses build the ability you are paying to acquire and which quietly replace it.

• Teachers: user of the tool, referee of its use Shared methods

  Teaching hands you both roles at once. The rules for preparing your lessons with AI and the rules for policing your students' use are not the same rules.

• Universities: policy that survives contact with students Shared methods

  A ban nobody follows is worse than no policy. What UNESCO actually asks institutions to do, and the ingredients of a rule students can comply with.

• Writers and editors Shared methods

  A reading order for people whose output is prose, plus the four things that land differently when the writing is the product.

Developer workflows

Complete tasks, hand off checked artifacts, and automate stages across providers.

• Make artifacts and human decisions explicit Shared methods

  Bind approval to the exact evidence and change being reviewed, and stop stale decisions from authorizing later work.

• Plan, implement, and review across providers Requires: Claude Code + Codex + Gemini CLI

  Coordinate a bounded change with a reviewed plan, isolated candidate artifacts, independent reviews, and an explicit acceptance decision.

• Recover a pipeline without losing its boundaries Shared methods

  Handle failed output, denied decisions, cancellation, retries, and limited budgets while preserving the run's evidence.

• Review a change with another provider Requires: Claude Code + Gemini CLI

  Give independent reviewers the same fixed evidence, validate their findings, and let a human decide the result.

• Run API and coding-agent stages in one reviewed pipeline Requires: Gemini API + Claude Code + Codex + OpenAI API

  Configure direct model calls alongside CLI jobs, inspect their request limits, and stop uncertain work before another dispatch.

• Run CLI stages between human decisions Requires: Claude Code + Codex + Gemini CLI

  Configure Claude Code, Codex, and Gemini CLI, review their execution profile, and let the local coordinator launch and supervise eligible stages.

• Turn a working handoff into a developer pipeline Shared methods

  Automate a known stage, keep its evidence, and retain human decisions at the points where they matter.

• Turn research into a checked code change Requires: Gemini API + Claude Code + Codex + OpenAI API

  Carry selected source evidence through planning, implementation, and review while keeping uncertainty and human decisions visible.

• Workflow: a refactor across several files Claude + Claude Code + Anthropic API

  The plan is 1% of the tokens and decides the other 99%. Everything else is mechanical, and mechanical work does not need the expensive model.

• Workflow: debugging a failure Claude + Claude Code + Anthropic API

  Narrowing costs four times what diagnosing costs. Put the cheap model on the search and the expensive one on the thirty seconds that decide the answer.

• Workflow: researching and synthesising Claude + Claude Code + Anthropic API

  Reading thirty sources costs eight times what thinking about them costs. This is the workflow where model choice saves the most.

• Workflow: reviewing a change Claude + Claude Code + Anthropic API

  Three steps, three different models. Reading is not judging, and paying Opus rates to read a diff is the commonest waste in this workflow.

Reference

Model matrix, glossary, quota, where to go instead of here.

• Check Gemini, Gemini CLI, and API access Gemini + Gemini CLI + Gemini API

  Separate a developer's Google sign-in, CLI authentication, API project, and effective model access.

• Check your ChatGPT, Codex, and API access ChatGPT + Codex + OpenAI API

  Identify the account and billing path actually used by a developer task, including Codex hosted inside an IDE.

• Compare API cost and context correctly Anthropic API + OpenAI API + Gemini API

  Separate cumulative usage from peak context, account for the chosen pricing conditions, and measure quality independently.

• Official documentation, and when to go there instead Shared methods

  This site covers decisions and failure modes. For what a button does, what a model costs, or what a contract says, the vendor's own pages are better.

• What changed on this site Claude

  Corrections, retractions and findings worth knowing about if you read something here before. Silent on typos and tidying.