Troiana AI Hub · Curated library

ChatGPT, Claude & Codex Prompt Library

Curated ChatGPT, Claude, and Codex prompts for product, research, writing, debugging, testing, and software delivery. Each prompt explains the outcome, context to add, and how to use the result responsibly.

Browse prompts by task

Write a clear product requirements doc — Turn a rough product idea into a usable PRD with decisions and acceptance criteria.
Turn an idea into a product brief — Frame a product opportunity before the team jumps to features.
Prioritise a product backlog — Rank a backlog against impact, effort, confidence, and strategic fit.
Write user stories with acceptance criteria — Convert a product concept into testable user stories.
Build a Now, Next, Later roadmap — Turn priorities into a roadmap that communicates intent without fake certainty.
Define product success metrics — Choose measures that reveal whether a product change created value.
Analyse churn feedback — Find the recurring product problems behind cancellation or downgrade feedback.
Improve an onboarding flow — Diagnose friction in a first-use journey and propose focused improvements.
Plan a product launch — Coordinate the product decisions, readiness checks, and communication for a release.
Evaluate a pricing change — Stress-test a pricing idea against customer value, risks, and evidence.
Run a product discovery workshop — Structure a session that produces shared understanding instead of a wall of sticky notes.
Define a product problem statement — Sharpen a vague complaint into a problem a team can actually solve.
Write an opportunity assessment — Judge whether a product opportunity is worth committing a team to.
Segment product users — Group users by behaviour and need rather than by convenient demographics.
Map a product user journey — Trace the real path a user takes, including the parts that happen outside your product.
Formulate product hypotheses — Turn an assumption into a statement that evidence can confirm or reject.
Design a product experiment — Plan a test that will actually settle the question it was built to answer.
Evaluate a feature request — Assess a request against the underlying need rather than the proposed solution.
Calculate product opportunity size — Estimate the value of an opportunity honestly, including the parts you cannot know.
Choose an MVP scope — Decide the smallest build that genuinely tests the thing you are unsure about.
Plan a feature-flag rollout — Release progressively so problems surface while they are still small.
Define product non-goals — Write down what the product will deliberately not do, and why.
Align product stakeholders — Find the real disagreement behind a stalled decision and resolve it.
Write a product decision memo — Record a decision so future readers understand the reasoning, not just the outcome.
Create a product discovery plan — Right-size discovery to the risk of the decision in front of you.
Run a product teardown — Analyse a product's decisions to learn from them rather than to rate it.
Evaluate build versus buy — Compare building, buying, and integrating against total cost and strategic control.
Create a customer feedback loop — Build a route from customer signal to product decision that does not depend on heroics.
Assess product retention — Understand who stays, who leaves, and what genuinely separates them.
Plan a private beta — Run a limited release that produces real learning, not just early access.
Run a product review meeting — Structure a review that produces decisions instead of a status update.
Create a product analytics plan — Decide what to measure before instrumenting, so the data can answer real questions.
Write product release notes — Tell users what changed in terms of what they can now do.
Plan a product deprecation — Retire a feature without damaging trust or stranding the people using it.
Assess product risk — Identify what could go wrong before it does, and decide what to do about it.
Audit a product portfolio — Review a set of products or features against strategy, cost, and performance.
Design a product feedback survey — Write a survey that yields usable answers instead of confirming what you assumed.
Plan a customer advisory board — Set up a forum that produces strategic insight rather than a feature wishlist.
Map product dependencies — Surface what a piece of work depends on before it blocks a date.
Define product personas — Build personas grounded in research that actually change design decisions.
Create a packaging strategy — Decide how capability is grouped into tiers customers can understand and choose between.
Plan a marketplace feature — Design for both sides of a two-sided product, including the cold start.
Develop a product vision — Describe a future worth building that also guides present decisions.
Write a product strategy narrative — Explain how the product wins in prose rather than a slide of arrows.
Resolve conflicting requirements — Find the decision hiding underneath two requirements that cannot both be satisfied.
Prioritise technical debt — Decide which debt to pay down using product impact, not engineering discomfort.
Plan product internationalisation — Prepare a product for other languages and markets before it is expensive to retrofit.
Map an adoption funnel — Trace the path from first exposure to habitual use and find where it breaks.
Run a win-loss review — Learn why deals were actually won or lost, past the reason recorded in the CRM.
Create a product operating model — Define how product decisions get made, by whom, and on what rhythm.
Audit and improve UI copy — Strengthen clarity, tone, and consistency across a product surface.
Critique a product screen — Review a screen for hierarchy, comprehension, friction, and user confidence.
Map a user flow — Turn a task into a clear path with decisions, states, and failure handling.
Run an accessibility review — Check a design against practical accessibility risks before implementation.
Design empty, error, and loading states — Complete a product experience beyond its happy path.
Improve visual hierarchy — Make a dense screen easier to scan and act on.
Write a component specification — Define a reusable UI component clearly enough for design and engineering.
Synthesise usability test results — Turn session notes into credible usability findings and next steps.
Create a design system audit — Find inconsistency and missing foundations in an interface system.
Prepare a design handoff — Package design decisions so implementation starts with fewer assumptions.
Create a UX research handoff — A structured, evidence-led workflow for create a ux research handoff.
Design a responsive layout strategy — A structured, evidence-led workflow for design a responsive layout strategy.
Audit a mobile experience — A structured, evidence-led workflow for audit a mobile experience.
Improve form usability — A structured, evidence-led workflow for improve form usability.
Design a checkout flow — A structured, evidence-led workflow for design a checkout flow.
Create an information architecture — A structured, evidence-led workflow for create an information architecture.
Map a service blueprint — A structured, evidence-led workflow for map a service blueprint.
Plan a usability study — A structured, evidence-led workflow for plan a usability study.
Write a design rationale — A structured, evidence-led workflow for write a design rationale.
Create a wireframe brief — A structured, evidence-led workflow for create a wireframe brief.
Design a dashboard experience — A structured, evidence-led workflow for design a dashboard experience.
Improve a data visualisation — A structured, evidence-led workflow for improve a data visualisation.
Create an interaction design spec — A structured, evidence-led workflow for create an interaction design spec.
Plan a prototype test — A structured, evidence-led workflow for plan a prototype test.
Design a settings experience — A structured, evidence-led workflow for design a settings experience.
Improve navigation design — A structured, evidence-led workflow for improve navigation design.
Create a content hierarchy — A structured, evidence-led workflow for create a content hierarchy.
Design a notification system — A structured, evidence-led workflow for design a notification system.
Plan a design critique — A structured, evidence-led workflow for plan a design critique.
Audit design consistency — A structured, evidence-led workflow for audit design consistency.
Create a mobile onboarding flow — A structured, evidence-led workflow for create a mobile onboarding flow.
Design a search experience — A structured, evidence-led workflow for design a search experience.
Improve an e-commerce product grid — A structured, evidence-led workflow for improve an e-commerce product grid.
Create a permission-management flow — A structured, evidence-led workflow for create a permission-management flow.
Design a collaborative workflow — A structured, evidence-led workflow for design a collaborative workflow.
Plan an inclusive design review — A structured, evidence-led workflow for plan an inclusive design review.
Create a visual design direction — A structured, evidence-led workflow for create a visual design direction.
Define layout grid rules — A structured, evidence-led workflow for define layout grid rules.
Design a complex table — A structured, evidence-led workflow for design a complex table.
Improve a conversion form — A structured, evidence-led workflow for improve a conversion form.
Create a modal interaction pattern — A structured, evidence-led workflow for create a modal interaction pattern.
Design a help centre flow — A structured, evidence-led workflow for design a help centre flow.
Plan a design sprint — A structured, evidence-led workflow for plan a design sprint.
Create a design research readout — A structured, evidence-led workflow for create a design research readout.
Audit responsive breakpoints — A structured, evidence-led workflow for audit responsive breakpoints.
Design a multi-step wizard — A structured, evidence-led workflow for design a multi-step wizard.
Improve a checkout confirmation — A structured, evidence-led workflow for improve a checkout confirmation.
Create an account-management flow — A structured, evidence-led workflow for create an account-management flow.
Design a trust-and-safety flow — A structured, evidence-led workflow for design a trust-and-safety flow.
Prepare a design QA checklist — A structured, evidence-led workflow for prepare a design qa checklist.
Plan a feature in an unfamiliar codebase — Map the codebase and draft a safe, implementation-ready plan.
Review a pull request with intent — Check a change for correctness, risk, test gaps, and clarity before it ships.
Add tests for a changed feature — Find the right test seams and add meaningful coverage for a feature change.
Debug a failing production path — Create a disciplined investigation plan before changing code under pressure.
Plan a safe refactor — Reduce technical debt without losing sight of behaviour and rollout risk.
Investigate a performance regression — Isolate what made a service, page, or workflow slower.
Design an API integration — Plan a reliable integration across contracts, failures, and observability.
Run a focused security review — Review a change for common security, privacy, and abuse risks.
Plan a data migration — Move or reshape production data without avoidable downtime or corruption.
Write an incident postmortem — Turn an outage or defect into learning without blame or vague actions.
Plan a bug fix in an unfamiliar service — A structured, evidence-led workflow for plan a bug fix in an unfamiliar service.
Review a database schema change — A structured, evidence-led workflow for review a database schema change.
Design a background job — A structured, evidence-led workflow for design a background job.
Investigate a memory leak — A structured, evidence-led workflow for investigate a memory leak.
Plan an authentication change — A structured, evidence-led workflow for plan an authentication change.
Implement an observability strategy — A structured, evidence-led workflow for implement an observability strategy.
Review an error-handling path — A structured, evidence-led workflow for review an error-handling path.
Design a caching strategy — A structured, evidence-led workflow for design a caching strategy.
Plan a frontend performance audit — A structured, evidence-led workflow for plan a frontend performance audit.
Create an integration test plan — A structured, evidence-led workflow for create an integration test plan.
Review a dependency upgrade — A structured, evidence-led workflow for review a dependency upgrade.
Plan a CI pipeline improvement — A structured, evidence-led workflow for plan a ci pipeline improvement.
Design a webhook consumer — A structured, evidence-led workflow for design a webhook consumer.
Investigate flaky tests — A structured, evidence-led workflow for investigate flaky tests.
Create a feature rollout plan — A structured, evidence-led workflow for create a feature rollout plan.
Plan a monolith extraction — A structured, evidence-led workflow for plan a monolith extraction.
Review a concurrency risk — A structured, evidence-led workflow for review a concurrency risk.
Design a rate-limiting strategy — A structured, evidence-led workflow for design a rate-limiting strategy.
Plan a logging standard — A structured, evidence-led workflow for plan a logging standard.
Investigate a failed deployment — A structured, evidence-led workflow for investigate a failed deployment.
Create a rollback plan — A structured, evidence-led workflow for create a rollback plan.
Review a codebase architecture — A structured, evidence-led workflow for review a codebase architecture.
Plan an accessibility implementation — A structured, evidence-led workflow for plan an accessibility implementation.
Design a data validation layer — A structured, evidence-led workflow for design a data validation layer.
Review an API contract — A structured, evidence-led workflow for review an api contract.
Plan a secrets-management improvement — A structured, evidence-led workflow for plan a secrets-management improvement.
Create a release checklist — A structured, evidence-led workflow for create a release checklist.
Investigate a production alert — A structured, evidence-led workflow for investigate a production alert.
Plan an event-driven workflow — A structured, evidence-led workflow for plan an event-driven workflow.
Review a storage-cost problem — A structured, evidence-led workflow for review a storage-cost problem.
Design a file-upload flow — A structured, evidence-led workflow for design a file-upload flow.
Plan a service-level objective — A structured, evidence-led workflow for plan a service-level objective.
Create a developer onboarding guide — A structured, evidence-led workflow for create a developer onboarding guide.
Review a legacy module — A structured, evidence-led workflow for review a legacy module.
Plan a dependency cleanup — A structured, evidence-led workflow for plan a dependency cleanup.
Design a queue-processing workflow — A structured, evidence-led workflow for design a queue-processing workflow.
Investigate a database slow query — A structured, evidence-led workflow for investigate a database slow query.
Plan a frontend state refactor — A structured, evidence-led workflow for plan a frontend state refactor.
Create a code quality audit — A structured, evidence-led workflow for create a code quality audit.
Write an engineering decision record — A structured, evidence-led workflow for write an engineering decision record.
Turn research into decisions — Extract patterns, implications, and confident next steps from raw research.
Write a user interview guide — Prepare an interview that uncovers behaviour rather than leading people to answers.
Synthesise customer interviews — Find recurring patterns and important differences across interviews.
Run a competitor analysis — Compare alternatives through customer value and positioning, not feature-counting.
Analyse survey results — Interpret quantitative and qualitative survey evidence carefully.
Define jobs to be done — Translate customer evidence into functional, emotional, and social jobs.
Map a market landscape — Create a structured view of players, segments, trends, and uncertainty.
Write a research plan — Choose a right-sized research approach for a decision at stake.
Create an opportunity solution tree — Connect desired outcomes to customer opportunities and testable solutions.
Assess evidence quality — Check whether a claim is strong enough to inform a real decision.
Plan a diary study — A structured, evidence-led workflow for plan a diary study.
Analyse support-ticket themes — A structured, evidence-led workflow for analyse support-ticket themes.
Create a research repository taxonomy — A structured, evidence-led workflow for create a research repository taxonomy.
Run a pricing research study — A structured, evidence-led workflow for run a pricing research study.
Map a customer decision journey — A structured, evidence-led workflow for map a customer decision journey.
Prepare a stakeholder interview — A structured, evidence-led workflow for prepare a stakeholder interview.
Analyse product-review sentiment — A structured, evidence-led workflow for analyse product-review sentiment.
Create a segmentation study — A structured, evidence-led workflow for create a segmentation study.
Plan a concept test — A structured, evidence-led workflow for plan a concept test.
Run a message test — A structured, evidence-led workflow for run a message test.
Synthesize diary-study entries — A structured, evidence-led workflow for synthesize diary-study entries.
Create a research recruitment screener — A structured, evidence-led workflow for create a research recruitment screener.
Evaluate a prototype study — A structured, evidence-led workflow for evaluate a prototype study.
Map a service ecosystem — A structured, evidence-led workflow for map a service ecosystem.
Plan an ethnographic study — A structured, evidence-led workflow for plan an ethnographic study.
Analyse sales-call transcripts — A structured, evidence-led workflow for analyse sales-call transcripts.
Create a research readout — A structured, evidence-led workflow for create a research readout.
Assess research bias — A structured, evidence-led workflow for assess research bias.
Run a card-sorting study — A structured, evidence-led workflow for run a card-sorting study.
Plan a longitudinal study — A structured, evidence-led workflow for plan a longitudinal study.
Map a stakeholder ecosystem — A structured, evidence-led workflow for map a stakeholder ecosystem.
Create a competitor feature matrix — A structured, evidence-led workflow for create a competitor feature matrix.
Analyse search-query behaviour — A structured, evidence-led workflow for analyse search-query behaviour.
Plan a usability benchmark — A structured, evidence-led workflow for plan a usability benchmark.
Create a customer journey research plan — A structured, evidence-led workflow for create a customer journey research plan.
Assess market demand — A structured, evidence-led workflow for assess market demand.
Run a brand-perception study — A structured, evidence-led workflow for run a brand-perception study.
Create a research consent form — A structured, evidence-led workflow for create a research consent form.
Analyse open-ended survey answers — A structured, evidence-led workflow for analyse open-ended survey answers.
Plan a co-creation workshop — A structured, evidence-led workflow for plan a co-creation workshop.
Create a trend-research brief — A structured, evidence-led workflow for create a trend-research brief.
Evaluate a value proposition — A structured, evidence-led workflow for evaluate a value proposition.
Map switching behaviour — A structured, evidence-led workflow for map switching behaviour.
Plan a customer advisory interview — A structured, evidence-led workflow for plan a customer advisory interview.
Analyse win-loss interviews — A structured, evidence-led workflow for analyse win-loss interviews.
Create a research insight narrative — A structured, evidence-led workflow for create a research insight narrative.
Assess sample quality — A structured, evidence-led workflow for assess sample quality.
Run a task-analysis study — A structured, evidence-led workflow for run a task-analysis study.
Plan a field research visit — A structured, evidence-led workflow for plan a field research visit.
Create a research decision log — A structured, evidence-led workflow for create a research decision log.
Create a competitive positioning brief — Turn a market scan into a credible position, not a list of competitor features.
Build a messaging framework — Create a reusable message architecture for a product or brand.
Write a high-converting landing page — Shape a landing page around a buyer’s problem, proof, and next action.
Write a campaign brief — Align a campaign around one audience, one objective, and a believable message.
Define a brand voice — Turn vague tone preferences into usable writing principles.
Create a content brief — Plan a useful piece of content around a search or audience need.
Plan a go-to-market strategy — Coordinate audience, offer, channels, readiness, and measurement for a launch.
Research a target audience — Build a practical audience picture from available evidence.
Write a persuasive case study — Turn project evidence into a credible customer story.
Write a customer email sequence — Create a useful sequence that earns attention across several touches.
Create a brand messaging audit — A structured, evidence-led workflow for create a brand messaging audit.
Write a homepage messaging strategy — A structured, evidence-led workflow for write a homepage messaging strategy.
Plan a product marketing campaign — A structured, evidence-led workflow for plan a product marketing campaign.
Create a customer acquisition strategy — A structured, evidence-led workflow for create a customer acquisition strategy.
Write a value proposition — A structured, evidence-led workflow for write a value proposition.
Develop a campaign concept — A structured, evidence-led workflow for develop a campaign concept.
Plan an account-based marketing programme — A structured, evidence-led workflow for plan an account-based marketing programme.
Create a demand-generation plan — A structured, evidence-led workflow for create a demand-generation plan.
Write a product launch email — A structured, evidence-led workflow for write a product launch email.
Develop a partner marketing plan — A structured, evidence-led workflow for develop a partner marketing plan.
Create a referral programme — A structured, evidence-led workflow for create a referral programme.
Plan a customer advocacy campaign — A structured, evidence-led workflow for plan a customer advocacy campaign.
Write a sales battlecard — A structured, evidence-led workflow for write a sales battlecard.
Create an objection-handling guide — A structured, evidence-led workflow for create an objection-handling guide.
Develop a webinar promotion plan — A structured, evidence-led workflow for develop a webinar promotion plan.
Plan a brand awareness campaign — A structured, evidence-led workflow for plan a brand awareness campaign.
Create a media outreach plan — A structured, evidence-led workflow for create a media outreach plan.
Write a product comparison guide — A structured, evidence-led workflow for write a product comparison guide.
Plan a lifecycle marketing programme — A structured, evidence-led workflow for plan a lifecycle marketing programme.
Create a retention marketing campaign — A structured, evidence-led workflow for create a retention marketing campaign.
Develop a seasonal campaign — A structured, evidence-led workflow for develop a seasonal campaign.
Write a marketing performance review — A structured, evidence-led workflow for write a marketing performance review.
Create a channel strategy — A structured, evidence-led workflow for create a channel strategy.
Plan a paid-search campaign — A structured, evidence-led workflow for plan a paid-search campaign.
Develop a social advertising brief — A structured, evidence-led workflow for develop a social advertising brief.
Write a customer persona narrative — A structured, evidence-led workflow for write a customer persona narrative.
Create a conversion-rate optimisation plan — A structured, evidence-led workflow for create a conversion-rate optimisation plan.
Plan a marketing experiment — A structured, evidence-led workflow for plan a marketing experiment.
Develop a brand partnership pitch — A structured, evidence-led workflow for develop a brand partnership pitch.
Create a field marketing plan — A structured, evidence-led workflow for create a field marketing plan.
Write a customer story campaign — A structured, evidence-led workflow for write a customer story campaign.
Plan a community growth strategy — A structured, evidence-led workflow for plan a community growth strategy.
Develop a launch positioning matrix — A structured, evidence-led workflow for develop a launch positioning matrix.
Create a marketing budget proposal — A structured, evidence-led workflow for create a marketing budget proposal.
Write an executive marketing update — A structured, evidence-led workflow for write an executive marketing update.
Plan a rebrand communications strategy — A structured, evidence-led workflow for plan a rebrand communications strategy.
Create a demand-capture plan — A structured, evidence-led workflow for create a demand-capture plan.
Develop a partner co-marketing brief — A structured, evidence-led workflow for develop a partner co-marketing brief.
Write a marketing team charter — A structured, evidence-led workflow for write a marketing team charter.
Create a marketing measurement framework — A structured, evidence-led workflow for create a marketing measurement framework.
Write an SEO content brief — Turn a search opportunity into a writer-ready brief.
Build a keyword topic cluster — Organise related queries into pages that can earn topical authority.
Analyse search intent — Determine what a searcher expects before drafting content.
Outline a pillar article — Create an authoritative long-form structure without padding it with filler.
Optimise an existing article — Improve a published article for clarity, relevance, and search usefulness.
Write meta titles and descriptions — Create search snippets that accurately earn qualified clicks.
Plan internal links for an article — Connect a draft to the most helpful related pages on the site.
Write an FAQ section — Answer the questions readers genuinely need resolved before acting.
Refresh a decaying article — Diagnose why a once-useful article is losing relevance or traffic.
Find content gaps — Identify useful topics a site has not yet answered well.
Edit a draft for clarity — Make a draft easier to understand without flattening its point of view.
Create an editorial style guide — Turn a desired voice into rules writers can apply consistently.
Rewrite for a busy executive — Condense an important message for a reader with little time.
Write a thought-leadership article — Develop an original point of view backed by credible experience and evidence.
Turn an interview into an article — Shape an interview into a narrative readers will finish and remember.
Write an op-ed — Make a timely argument with a clear stake and a defensible point of view.
Write a case study article — Turn a project into an evidence-led story of decisions and outcomes.
Write a newsletter edition — Create a useful, skimmable edition that earns a reader’s next open.
Write an email course — Teach a useful idea through a sequenced series of short lessons.
Create a LinkedIn post — Turn an expert insight into a credible professional social post.
Write a social media thread — Break a complex point into a sequence readers can follow and share.
Plan a social content series — Create a coherent run of posts around one audience need or theme.
Write a carousel script — Structure a swipeable social story that rewards each next slide.
Write a short video script — Turn one idea into a concise, watchable short-form video.
Write a YouTube video script — Build a longer video around a clear viewer promise and retention structure.
Write podcast show notes — Package an episode so listeners can understand, find, and act on its value.
Write a webinar abstract — Explain why a live session is worth a busy person’s time.
Write a press release — Communicate a newsworthy announcement with facts, context, and usable quotes.
Write a founder announcement — Help a founder communicate a meaningful company update with candour.
Write a landing page — Create a focused page that connects an offer to a buyer’s real problem.
Write a product page — Explain a product feature or offer in language that helps buyers decide.
Generate headline variants — Explore distinct headline directions without drifting into generic copy.
Create a call-to-action bank — Write purposeful CTAs for different moments in a customer journey.
Write customer proof snippets — Turn testimonials and results into concise evidence that supports a claim.
Write an onboarding email sequence — Guide a new user toward early value through helpful, timed emails.
Write a re-engagement email — Invite an inactive audience back with a reason that respects their attention.
Write a sales one-pager — Distil an offer into a concise document a buyer can understand and share.
Create a lead magnet — Develop a genuinely useful downloadable resource for a defined audience.
Write a comparison page — Help buyers compare alternatives fairly while explaining where your offer fits.
Build an editorial calendar — Turn strategic themes into a realistic publishing plan.
Repurpose a pillar piece — Turn one strong asset into channel-appropriate follow-on content.
Plan content distribution — Match distribution tactics to the audience and purpose of a published piece.
Write a writer brief — Give a writer enough strategic direction without dictating every sentence.
Run a content quality review — Check a draft for accuracy, usefulness, brand fit, and editorial craft.
Localise content for a market — Adapt content for a region or audience without merely translating words.
Rewrite in plain language — Make important information understandable without losing its meaning.
Create a user-generated content brief — Invite customers or creators to make authentic content with useful guardrails.
Write a community response — Respond to a customer or community issue with clarity, empathy, and accountability.
Write a brand narrative — Articulate the story connecting a company’s origin, conviction, and customer value.
Write a content manifesto — Define the editorial beliefs that make a publication worth following.
Pressure-test a PRD before committing a team — Have Claude think through a requirements doc properly and surface what it quietly assumes.
Build a prioritisation model you can actually adjust — Turn a backlog and its scoring assumptions into a working artifact you can re-weight live.
Analyse a full quarter of customer feedback at once — Put the whole feedback corpus in context rather than sampling it, and find what actually recurs.
Set up a product Project with durable context — Give Claude the strategy, constraints, and vocabulary once so every later conversation inherits them.
Chain discovery into a decision memo — Run discovery as separate passes — evidence, then interpretation, then recommendation — instead of one blurred answer.
Red-team a product strategy — Make Claude argue the strongest case against the strategy you have already chosen.
Turn a metric tree into a live dashboard — Build the measurement model as an artifact the team can interrogate rather than a static diagram.
Interrogate a competitor corpus — Load competitor pages, docs, pricing, and changelogs together and ask what the pattern reveals.
Verify a product claim against its evidence — Check whether a stated conclusion is actually supported by the data behind it.
Structure a messy product decision — Use explicit tagged sections so Claude keeps your constraints, evidence, and question separate.
Build a churn analysis workspace — Keep cancellation data, prior analyses, and product context together so investigations compound.
Draft a roadmap and its counter-argument — Produce the plan and, in the same pass, the case that the plan is wrong.
Reason through a pricing change before committing — Work out what a pricing move does to each segment before it reaches a customer.
Find the assumption your business case rests on — Trace a business case back to the one belief that, if wrong, collapses it.
Work out why a metric actually moved — Separate real change from seasonality, mix shift, and measurement artefacts.
Decide whether to sunset a feature — Weigh the cost of keeping a feature against the cost of taking it away from the people using it.
Think through a marketplace cold start — Reason about how a two-sided product reaches liquidity before it has either side.
Examine a build-versus-buy decision properly — Compare building, buying, and integrating across the full life of the capability, not its first release.
Stress-test a launch date — Find what will actually make the date slip before it does.
Build an opportunity sizing model you can adjust — Turn a sizing estimate into an artifact where the assumptions are visible and changeable.
Turn a roadmap into a shareable interactive view — Produce the roadmap as something stakeholders can explore rather than a slide that goes stale.
Build a cohort retention explorer — Make retention differences visible and interrogable instead of averaged into one curve.
Create an experiment results calculator — Build the significance and effect-size maths into something the team can use without a statistician.
Build a feature comparison matrix for a buy decision — Compare vendor options against your criteria with the evidence attached.
Turn a persona set into a working reference — Make personas something the team consults during decisions rather than a deck nobody reopens.
Read an entire support backlog for product signal — Analyse every ticket rather than the ones that escalated, and find what the product is causing.
Analyse every sales call from a quarter — Find the objections, gaps, and misunderstandings that recur across a whole quarter of calls.
Review a full year of release notes for drift — Read everything you shipped in a year and see whether it matches the strategy you claimed.
Digest an analytics export without sampling — Analyse a full behavioural export rather than the summary dashboard view.
Compare every competitor's pricing page at once — Read the whole competitive pricing landscape together and find the structural pattern.
Mine a community forum for unmet needs — Read a whole forum or subreddit and find the problems people work around silently.
Read a contract set for product constraints — Find the commitments buried across agreements that constrain what the product can do.
Set up a Project for a product line you own — Give Claude one product line's strategy, users, and constraints permanently.
Give Claude your metric definitions permanently — Store how your metrics are actually defined so analysis stops using the obvious interpretation.
Build a Project around your customer evidence — Keep the research, feedback, and interviews in one place so answers cite real customers.
Store your product principles as standing rules — Turn the judgement calls your team makes repeatedly into rules Claude applies by default.
Keep a competitor watch Project current — Maintain accumulated competitor knowledge so each new development is read against its history.
Chain a metric anomaly into a root cause — Move from the observation to the cause in reviewable steps rather than one confident leap.
Chain user research into a prioritised backlog — Get from research findings to ranked work without losing the reasoning in between.
Chain a business case into a staged plan — Turn an approved case into stages with decision gates rather than one committed programme.
Chain a churn signal into a retention experiment — Move from a churn pattern to a testable intervention in traceable steps.
Chain a support theme into a product change — Trace a recurring support issue through to the change that would eliminate it.
Specify an experiment with tagged constraints — Give the hypothesis, the constraints, and the guardrails as separate inputs so none is traded away silently.
Frame a build-or-kill decision with explicit inputs — Lay out the evidence, the constraints, and the commitments so the decision is not driven by sunk cost.
Structure a stakeholder disagreement — Separate what people disagree about factually from what they disagree about in priority.
Define a segment with explicit inclusion rules — Make a segment precise enough to find in your data and act on differently.
Specify a pricing tier boundary — Decide precisely what separates one tier from the next and why a customer would move.
Verify a roadmap against its stated strategy — Check whether the planned work actually pursues the strategy it claims to.
Check an experiment result before you act on it — Test whether a result is real before it becomes a decision.
Audit a business case for unsupported assumptions — Go through a case line by line and separate what is evidenced from what is asserted.
Critique a screen against a rubric you set — Give Claude the evaluation criteria explicitly so the critique is consistent rather than impressionistic.
Build a clickable prototype to test a flow — Turn a flow description into a working artifact people can actually click through.
Audit a design system from a token dump — Put the whole token set and component inventory in context and find the real inconsistencies.
Run an accessibility review that thinks it through — Have Claude reason carefully about how a design fails for real assistive-technology users.
Build a UX copy variant matrix — Generate and compare copy options for one surface as a side-by-side artifact.
Set up a design Project with your system context — Load the design system, patterns, and voice once so every critique is grounded in your actual system.
Chain research synthesis into interface decisions — Separate what the research found from what the interface should therefore do.
Produce a component spec with every state — Specify a component completely enough that implementation needs no guesswork.
Stress-test a flow against its edge cases — Have Claude work through what breaks when reality does not match the happy path.
Compare design directions on named criteria — Force an explicit comparison rather than a preference expressed as expertise.
Turn usability sessions into a prioritised fix list — Put every session in context together and find issues that recur across participants.
Verify a design against its stated requirements — Check systematically whether a design actually satisfies what it was asked to do.
Reason through a navigation restructure — Work out what a navigation change does to every existing path before committing to it.
Work out why users miss a key action — Reason about why a visible control is not being found or used.
Think through a progressive disclosure strategy — Decide what to show immediately and what to reveal only when it is needed.
Reason about a destructive action's safeguards — Work out how much friction a dangerous action deserves and where it should sit.
Decide between a modal and a page — Reason about the interaction pattern rather than defaulting to the familiar one.
Think through an offline and failure state strategy — Design for the conditions where the network or the system does not cooperate.
Reason about a dark pattern accusation — Examine honestly whether a design pressures users rather than serving them.
Build an interactive state explorer for a component — Make every state of a component visible at once instead of described in a list.
Build a responsive breakpoint preview — See how a layout behaves across sizes rather than reasoning about it from a spec.
Build a colour contrast checker for your palette — Test every foreground and background pairing in your system at once.
Build a type scale specimen — See the whole typographic system rendered together rather than as a table of values.
Build a form validation playground — Test validation timing and messaging interactively instead of specifying it in prose.
Build a motion and transition specimen — Make timing and easing decisions visible rather than described in milliseconds.
Read every support ticket about one screen — Find what a single interface is actually costing users, from their own descriptions.
Analyse a full set of session recordings — Review every session together and find behaviour that recurs across participants.
Audit every screen for pattern consistency — Compare the whole interface at once and find where the same problem is solved differently.
Review an entire content inventory for voice drift — Read all the interface copy together and find where the voice stops being consistent.
Analyse competitor interfaces at scale — Study many competing interfaces together and infer the conventions users now expect.
Read an accessibility audit report in full — Work through a complete audit and turn its findings into an ordered plan.
Set up a Project holding your design system — Give Claude the components, tokens, and rules permanently so feedback fits your system.
Store your accessibility standards as standing rules — Encode the accessibility bar once so every review applies it without being asked.
Build a Project around your user research — Keep the research evidence available so design decisions cite users rather than assumptions.
Keep a component decision log — Record why each component works the way it does, so the reasoning survives the team.
Chain a heuristic review into a redesign brief — Move from evaluation to design direction in reviewable steps.
Chain a user flow into wireframe requirements — Get from the flow to screen requirements without skipping the decisions in between.
Chain a design critique into a revision plan — Turn critique into an ordered plan rather than a list of comments to work through.
Chain an audit into a design system roadmap — Move from inconsistency findings to a sequenced consolidation plan.
Chain research findings into a testable prototype — Get from insight to a prototype that tests the specific thing you are unsure about.
Specify an interaction with tagged constraints — Give platform rules, accessibility requirements, and system constraints separately so none is traded away.
Frame a design trade-off explicitly — Lay out what each option costs so the decision is made knowingly.
Write a design brief with explicit success criteria — Define what the design must achieve before exploring how it looks.
Define empty state requirements systematically — Specify what each empty state must do rather than treating it as a placeholder.
Specify error messages with their recovery paths — Write errors that tell the user what happened and what to do next.
Verify a build against the design spec — Check systematically whether the implementation matches what was specified.
Verify a design against accessibility requirements — Check the design against each requirement rather than reviewing it impressionistically.
Check that a flow handles every state it claims — Verify that the specified states actually exist and behave as described.
Verify copy against the voice guidelines — Check interface copy against the standards it is supposed to follow.
Check a component against its design tokens — Verify that an implementation uses the system's tokens rather than hardcoded values.
Plan a feature across a whole repository — Let Claude Code explore the codebase itself before proposing an implementation plan.
Review a diff for what the tests do not cover — Have Claude reason about the regression risk in a change rather than comment on its style.
Trace a bug through a long stack and its code — Put the trace, the logs, and the relevant source in one context and reason across all of it.
Wire an internal tool through MCP — Connect a real data source or service so Claude works against live systems instead of pasted output.
Migrate a codebase pattern file by file — Drive a repetitive migration with verification at each step instead of one large unreviewable change.
Chain a refactor into verifiable commits — Break structural change into steps where each one independently preserves behaviour.
Write an ADR including the rejected options — Record an architecture decision so its reasoning survives the people who made it.
Red-team a security-sensitive change — Make Claude attack the change before someone else does.
Generate a test matrix as a working artifact — Turn coverage gaps into a matrix you can see and tick off.
Set up a Claude Project for a service you own — Give Claude the architecture, conventions, and operational context of one service permanently.
Verify AI-written code before it ships — Check generated code against the behaviour it was supposed to implement.
Investigate a production incident under pressure — Impose a disciplined investigation sequence when the temptation is to start changing code.
Map an unfamiliar codebase before changing it — Have Claude Code read the repository and explain how it actually fits together.
Find every caller before changing a signature — Locate all real usages across the repository instead of trusting a text search.
Reproduce a bug from a report — Turn a vague report into a reliable reproduction by exploring the actual code paths.
Add a feature following existing conventions — Implement in the codebase's own idiom rather than a generically correct style.
Delete dead code safely — Establish what is genuinely unreachable before removing it.
Bring test coverage to a legacy module — Characterise what existing code actually does before changing it.
Trace a data flow end to end — Follow a piece of data through the whole system and find where it is transformed.
Audit a repository for a specific risk — Sweep the whole codebase for one class of problem rather than reviewing file by file.
Connect your database through MCP — Query real data during analysis instead of pasting result sets into the conversation.
Connect your issue tracker through MCP — Let Claude read real tickets rather than working from pasted summaries.
Connect your observability stack through MCP — Query logs, traces, and metrics directly while investigating.
Build an MCP server for an internal service — Expose your own service so Claude can work with it directly.
Reason about a race condition — Work through the interleavings that produce an intermittent failure.
Work out whether a change is backwards compatible — Examine a change against every consumer that depends on the current behaviour.
Reason about a distributed failure mode — Think through what happens when part of a distributed operation fails.
Decide on a database migration strategy — Work out how to change a schema while the system stays available.
Reason about a caching correctness problem — Work out where stale data can appear and what it would cost.
Work through an error handling strategy — Decide which failures to retry, surface, or swallow, and why.
Reason about an authorisation model — Work through who can do what before encoding it in code.
Analyse a large log export for a failure pattern — Read the whole export and find what precedes each failure.
Review a large pull request coherently — Assess a big change as a whole rather than file by file.
Audit a dependency tree for risk — Assess the whole dependency graph rather than the direct dependencies.
Reconstruct a system's behaviour from its tests — Read the whole test suite to learn what the system is supposed to do.
Analyse a profiling trace for the real bottleneck — Read a full trace and find where the time is actually going.
Review a whole service for consistency — Read a service end to end and find where it contradicts its own conventions.
Set up a Project for your engineering standards — Encode how your team writes code once, so review and generation follow it by default.
Store your architecture decisions in a Project — Keep the ADRs available so proposals respect decisions already made.
Build a Project around your incident history — Keep past incidents available so new problems are read against what has already happened.
Keep your API contracts in a Project — Make the real contracts available so integration work matches what the API actually does.
Chain an investigation into a verified fix — Move from symptom to cause to fix, confirming each step before the next.
Chain a spec into an implementation plan into code — Keep specification, planning, and implementation as reviewable stages.
Chain a performance problem into a measured fix — Measure, diagnose, then optimise, rather than optimising what seems slow.
Chain a security finding into a hardened change — Move from vulnerability to fix to verification in checkable steps.
Chain a refactor plan into staged migration — Turn a structural plan into steps that each keep the system working.
Specify a change with tagged constraints — Give requirements, constraints, and conventions separately so none is silently traded away.
Define done for a piece of work — State what must be true before the work is finished, before it starts.
Write an interface contract precisely — Specify an interface completely enough that both sides can build against it.
Verify an implementation against its requirements — Check the code against what was asked rather than whether it looks correct.
Synthesise an entire interview corpus at once — Analyse every transcript together rather than one at a time, so cross-cutting patterns surface.
Argue against your own research findings — Have Claude build the strongest case that your conclusions are wrong.
Chain coding into themes into implications — Run analysis as distinct passes so interpretation cannot quietly precede the evidence.
Extract claims with citations you can check — Pull assertions out of a source set with the exact location of each supporting passage.
Build a competitor matrix you can interrogate — Turn competitive research into an artifact with the evidence attached to each cell.
Set up a research Project with your evidence base — Keep the study corpus, prior findings, and methods together so analyses build on each other.
Assess evidence quality before trusting it — Judge how much weight a body of evidence can actually bear.
Interrogate survey open-ends at full scale — Analyse every free-text response rather than reading a sample and generalising.
Design a study and pre-register its kill criteria — Decide in advance what result would change the decision, before the data can influence you.
Compare research methods on their trade-offs — Choose a method by what the decision needs rather than by habit.
Turn a research corpus into a decision readout — Compress a body of research into something a decision-maker can act on without losing the caveats.
Verify a research claim before it is quoted — Check that a finding about to be repeated publicly is actually what the data showed.
Analyse every open support conversation — Read the whole support corpus and find what users are consistently unable to do.
Synthesise a multi-round study — Analyse every round together and trace how understanding changed between them.
Read a full competitive review corpus — Analyse every public review of a competitor and find what their users actually complain about.
Analyse a full set of diary entries — Read a complete diary study and find the patterns that only appear over time.
Read an entire body of desk research — Work across every report, article, and dataset at once and find where they agree.
Analyse every churn survey response — Read all cancellation feedback and find the real reasons behind the stated ones.
Read a full accessibility user study — Analyse every session with assistive technology users and find the systemic barriers.
Analyse a longitudinal dataset for behaviour change — Read the full time series and separate real change from noise and seasonality.
Argue that your sample was not representative — Have Claude attack the generalisability of your findings.
Reason about causation versus correlation — Work out honestly whether your data can support the causal claim being made.
Work out why two studies disagree — Reason about what would produce contradictory findings on the same question.
Reason about what your research cannot answer — Establish the limits of the evidence before it is used for a decision.
Examine a surprising finding before believing it — Test an unexpected result against the mundane explanations first.
Reason about participant self-report reliability — Judge how much weight the things participants said can carry.
Work out the decision your research should serve — Establish what would actually change before designing the study.
Build an interactive findings explorer — Let stakeholders explore the evidence rather than read a fixed summary.
Build a research repository index — Make accumulated research findable by question rather than by project name.
Build a journey map you can interrogate — Turn a journey into something explorable rather than a static diagram.
Build a survey analysis dashboard — Make survey results explorable across segments instead of a fixed set of charts.
Build a persona evidence tracker — Keep personas tied to the evidence that produced them.
Build a study design checklist — Turn your methodological standards into something usable during planning.
Set up a Project for a research programme — Keep an ongoing programme's context, methods, and findings available across conversations.
Store your research methods as standing rules — Encode how your team runs research so quality does not depend on who is asked.
Build a Project of your customer segments — Keep segment definitions and evidence available so analysis uses real definitions.
Keep a research question backlog — Track the questions worth answering so research is prioritised rather than requested.
Chain a research question into a study design — Move from question to design with the reasoning visible at each step.
Chain transcripts into codes into themes — Run qualitative analysis as distinct passes so themes are grounded in codes.
Chain findings into recommendations into a plan — Keep evidence, interpretation, and action as separate reviewable stages.
Chain a hypothesis into a validation study — Move from a belief to a study that could genuinely disconfirm it.
Chain quantitative signals into qualitative questions — Use the numbers to decide what to ask people about.
Write a research plan with explicit constraints — State the decision, timeline, access, and ethical limits so the design is realistic.
Write an interview guide with explicit objectives — Separate what you need to learn from how you will ask, so questions serve the objective.
Define your analysis plan before collecting data — Decide how you will analyse the results before the data can influence the choice.
Write a screener with explicit criteria — Define who qualifies precisely so recruitment finds the right people.
Specify a research readout for its audience — State who is reading and what they must decide, so the readout serves them.
Verify a statistic before it is repeated — Check that a number means what it is being used to mean.
Check a synthesis against its source material — Verify that a synthesis actually reflects what participants said.
Verify that a recommendation follows from the evidence — Test whether the leap from finding to recommendation holds.
Build a messaging framework from structured inputs — Give Claude your audience, proof, and constraints as tagged sections so the framework stays grounded.
Generate a landing page as a working artifact — Produce the page as something you can see and click rather than a copy document.
Pressure-test positioning against its best objection — Have Claude make the strongest argument a sceptical buyer would make.
Analyse a full competitor content corpus — Load a competitor's pages, posts, and campaigns together and read the strategy behind them.
Chain audience research into campaign messaging — Keep the research findings and the creative message as separate, traceable steps.
Set up a brand voice Project Claude can hold — Load the voice, vocabulary, and boundaries once so every draft starts in the right register.
Build a campaign measurement dashboard — Turn the measurement plan into an artifact stakeholders can actually read.
Red-team a launch narrative — Find where the launch story will be attacked before it is published.
Generate channel variants from one core message — Adapt a single strategic message across channels without letting it drift into different claims.
Verify marketing claims against actual evidence — Check every claim on a page or in a campaign against the proof behind it.
Compare positioning options on named criteria — Evaluate candidate positions explicitly rather than converging on the most comfortable one.
Turn customer language into copy that converts — Mine real customer words from a large corpus and write from their vocabulary instead of yours.
Reason through a category positioning choice — Decide which category to compete in before writing anything about the product.
Work out why a campaign underperformed — Separate creative, targeting, offer, and timing before concluding the message was wrong.
Reason about a brand repositioning risk — Work out what a repositioning costs in recognition and trust before committing.
Think through a competitor's likely response — Anticipate how a competitor reacts to your move before you make it.
Work out whether a claim will survive scrutiny — Test a marketing claim against how a sceptic, a competitor, and a regulator would read it.
Reason about channel-market fit — Work out where your audience actually is rather than where campaigns are easiest to run.
Examine whether growth is real or borrowed — Work out whether results reflect genuine demand or pulled-forward and discounted volume.
Analyse every review of your product — Read the whole review corpus and find what customers consistently say about you.
Read a full year of campaign results — Analyse every campaign together and find what actually correlates with performance.
Analyse the whole competitive content landscape — Read everything competitors publish and find what nobody is saying.
Read every sales objection from a quarter — Find the objections that recur and the ones the messaging is causing.
Analyse an entire email programme's performance — Read every send together and find what actually drives engagement.
Read your whole website as a prospect would — Assess every page together as one experience rather than page by page.
Analyse a full set of win-loss interviews — Read every interview and find what actually decided the deals.
Build a positioning canvas you can revise — Turn positioning into an artifact the team can work on rather than a finished statement.
Build a messaging house for the whole team — Make the message architecture something people actually reference.
Build a campaign brief people can act on — Turn the brief into something with the strategy and the assets visible together.
Build a customer proof library — Organise testimonials, results, and quotes so they can be used where they are needed.
Build a competitive battlecard set — Give sales something usable in a live conversation rather than a document.
Build a content calendar with strategic threads — Make the calendar show the argument being built, not just the publishing dates.
Set up a Project holding your brand context — Give Claude the positioning, voice, proof, and constraints permanently.
Store your approved claims and proof — Keep the claims you can make and the evidence behind them in one authoritative place.
Build a Project around your ideal customer — Keep the audience evidence available so copy is written to a real person.
Keep a competitive intelligence Project current — Accumulate competitor knowledge so each new move is read in context.
Store your campaign learnings — Keep what worked and what did not so campaigns build on each other.
Chain audience evidence into positioning — Move from customer evidence to a position with the reasoning visible.
Chain positioning into channel executions — Get from position to executions without the message drifting in translation.
Chain a content strategy into a brief set — Move from strategy to individual briefs so each piece serves the whole.
Chain a launch narrative into channel assets — Build the story once, then adapt it, rather than writing each asset independently.
Chain performance data into a campaign revision — Move from results to diagnosis to changes in reviewable steps.
Write a creative brief with explicit boundaries — State the mandatories, the prohibitions, and the freedom so the work comes back usable.
Specify a landing page's single job — Define the one action and the one audience before any copy is written.
Define an audience with explicit boundaries — State who the work is for and, equally, who it is not for.
Specify a campaign's success criteria upfront — Define what success means before the campaign runs and can be reinterpreted.
Write a competitive comparison with explicit rules — Set the criteria and the fairness standard before writing anything about a competitor.
Verify a campaign's claims before launch — Check every claim in a campaign against its evidence and its approval status.
Check attribution before you trust it — Test whether the attributed results reflect what actually drove the outcome.
Verify that messaging matches the product — Check that what marketing promises is what the product actually does.
Edit a long manuscript without losing the thread — Hold an entire long document in context so the edit is consistent from first page to last.
Build an editorial style guide as a living artifact — Produce the guide as something writers can search and use rather than a document they skim once.
Chain an outline into a draft into a line edit — Run writing as separate passes so structure is settled before prose is polished.
Structure a content brief so Claude follows it — Give the brief as explicit tagged sections rather than prose Claude has to interpret.
Fact-check a draft claim by claim — Go through a draft systematically and separate what is supported from what is asserted.
Set up a publication Project with voice and standards — Load the voice, editorial standards, and prior work once so drafts start closer to publishable.
Argue the opposite of your thesis — Have Claude write the strongest version of the argument against the piece you are publishing.
Turn a transcript corpus into an article — Work across every transcript at once to find the story rather than summarising each conversation.
Build a headline test matrix — Generate genuinely different headline directions and compare them as an artifact.
Rewrite for a named reader with explicit constraints — Specify exactly who is reading and what they need, so the rewrite is targeted rather than generically simplified.
Audit a content library for decay and overlap — Analyse the whole library together and find what is stale, redundant, or cannibalising.
Generate an internal-link plan from your site corpus — Use the actual page inventory to propose links that serve readers rather than keyword targets.
Reason about what a piece is actually arguing — Establish the claim before deciding whether the draft supports it.
Work out why a piece is not landing — Diagnose whether the problem is the argument, the structure, the evidence, or the voice.
Reason about a topic's real audience — Work out who genuinely needs this piece rather than who might find it interesting.
Examine whether a piece justifies its length — Test whether every section earns its place in the reader's time.
Reason about publishing something contested — Think through the reaction before publishing a piece that will attract disagreement.
Work out the honest version of a claim — Find the strongest claim the evidence actually supports.
Analyse an entire back catalogue for voice — Read everything published and establish what the voice actually is.
Read a full research pack before drafting — Absorb all the source material at once so the piece uses the strongest evidence.
Analyse a competitor's entire content output — Read everything a competitor publishes and find what they never say.
Read a full comment and response corpus — Analyse everything readers have said and find what they consistently want.
Audit a whole documentation set for gaps — Read all the documentation together and find what it never explains.
Analyse a long transcript set for narrative — Read every transcript together and find the story across them.
Read an entire style corpus to match a voice — Absorb a body of writing well enough to write credibly in its register.
Build a living content style guide — Make the guide something writers search during drafting rather than read once.
Build an editorial calendar with visible threads — Show the argument the calendar is building rather than a schedule of dates.
Build a fact and source tracker — Keep claims tied to their sources so verification is possible later.
Build a headline and hook workshop — Compare genuinely different openings side by side.
Build a content repurposing map — Show what one substantial piece can become across formats.
Build a reader question index — Organise what readers ask so content answers real questions.
Set up a Project holding your editorial standards — Encode voice, standards, and structure once so drafts start closer to publishable.
Store your subject-matter reference material — Keep the domain knowledge available so writing is accurate without re-explanation.
Build a Project around your published archive — Make previous work available so new pieces build on it and link to it.
Keep your audience knowledge in a Project — Store what you know about readers so writing is aimed at real people.
Store your factual and legal constraints — Keep the claims you can make and the required caveats in one place.
Chain research into an argument into an outline — Establish what you can claim before deciding how to structure it.
Chain a draft through structural and line edits — Separate the structural pass from the sentence pass so both are done properly.
Chain an interview into quotes into a narrative — Move from transcript to story with the selection decisions visible.
Chain a topic into a keyword-informed brief — Use search evidence to shape the piece without letting it dictate the writing.
Chain a long piece into a distribution set — Turn one substantial piece into channel-appropriate follow-ons.
Write a brief with explicit non-goals — State what the piece will not cover so it does not expand while being written.
Specify a piece's reader and their decision — Define who is reading and what they should be able to do afterwards.
Define evidence standards for a piece — State what counts as adequate support before the drafting starts.
Structure a complex explanation deliberately — Choose the order in which ideas are introduced rather than following the topic's own structure.
Specify a rewrite's constraints explicitly — State what must be preserved so a rewrite improves without losing what worked.
Verify every factual claim in a draft — Check each assertion against its source before publication.
Check a piece against its brief — Verify that the draft does what it was commissioned to do.
Verify that quotes represent their source — Check that quoted material means what the piece uses it to mean.
Check a piece for unattributed borrowing — Verify that the work is original and its debts are acknowledged.

How to use this library

Start with the task, replace the placeholders with real context, then review the response before making a decision or changing code. These prompts are starting points for real work, not secret instructions or automatic answers.