pm-cowork

Enforce the simplest meeting rule that works — no agenda, no meeting — with the three-line agenda format (purpose, decisions sought, pre-reads), the 24-hour rule, and the graceful cancel scripts. Use when asked write an agenda for this meeting, should this meeting happen, our meetings have no agendas, or cancel this meeting politely. Produces the three-line agenda, the happen-or-cancel verdict, the cancel/convert scripts, and the team norm rollout.

Build an all-hands that lands with everyone from intern to VP — the mixed-altitude structure (the story for all, the numbers for some), the wins-with-names section done right, the hard-news slide handled straight, and the Q&A design that gets real questions. Use when asked build the all-hands deck, make the monthly town hall not boring, how do we share the numbers with everyone, or announce this change at all-hands. Produces the segment structure, the altitude-mixed content rules, the hard-news handling, and the Q&A mechanics.

Design the archive layer that keeps current workspaces lean without losing history — what moves, when, to where, findable-by-search, with the project-close ritual that makes archiving automatic instead of aspirational. Use when asked set up an archiving system, our workspace is drowning in old projects, when should things get archived, or make history findable without cluttering today. Produces the archive triggers, the destination structure, the findability rules, and the close-out ritual.

Convert a meeting into async work that actually decides — the doc-plus-deadline format that replaces the room, the comment-window rules, the decision-closure step that async usually fumbles, and the honest test for what still needs synchronous. Use when asked can this meeting be async, replace our status meeting with a doc, run this decision without a call, or async isn't working for us. Produces the conversion design, the async artifact format, the closure protocol, and the still-needs-a-room list.

Write status updates people actually read — the traffic-light-plus-narrative format (state first, story second), the blockers-are-asks rule, and the skimmable structure that respects a reader with thirty seconds. Use when asked write my weekly update, format our team's status posts, nobody reads my updates, or what goes in a good async check-in. Produces the update format with a filled example, the blockers-as-asks discipline, and the reader-time contract.

Turn a folder of accumulated documents into one decision-ready brief — the skim-map pass over the pile, the extraction against the brief's actual questions, the conflict reconciliation when documents disagree, and the provenance trail back to sources. Use when asked read all this and tell me what matters, synthesize this folder for the new lead, turn these 20 docs into a brief, or what does all this material actually say. Produces the pile map, the question-driven extraction, the reconciled brief with per-claim sources, and the didn't-read honesty ledger.

Design a budget-vs-actuals tracker that stays alive past February — the category grain that matches real statements, the variance view that answers 'are we okay', the update ritual small enough to survive, and the honest handling of irregular expenses. Use when asked build me a budget spreadsheet, track team spend against budget, why do we always blow the budget invisibly, or design a household/project budget tracker. Produces the tracker structure, the variance logic, the irregulars ledger, and the monthly fifteen-minute ritual.

Write changelogs and release notes readers actually benefit from — changes translated to so-whats, grouped by reader impact (breaking first, gifts second, plumbing last), with the upgrade path stated and the marketing kept honest. Use when asked write the release notes, turn this commit list into a changelog, announce this update to users, or why does nobody read our changelogs. Produces the impact-grouped changelog, the so-what translations, the breaking-changes block with migration steps, and the two-audience split when needed.

Fix a team's chat sprawl — the channel map with one purpose per channel, the naming scheme that makes purpose findable, the archive pass for the dead and duplicated, and the posting norms (threads, @-discipline, urgency signals) that keep signal findable. Use when asked clean up our Slack/Teams, we have 90 channels and nothing is findable, set channel norms, or where should things get posted. Produces the channel audit and map, the naming scheme, the norms card, and the archive pass.

Pick the chart the data and the point actually need — the question-to-chart mapping (comparison, trend, composition, distribution, relationship), the honesty rules (axes, baselines, dual-axis traps), and the one-chart-one-point discipline. Use when asked what chart should I use, make this data visual, why does this chart feel misleading, or fix this graph for the deck. Produces the chart verdict with its reasoning, the honesty checklist applied, and the labeling that lets the chart travel without its author.

Keep citations honest in business documents — every load-bearing claim sourced, links that actually contain the claim, the as-of dates that keep numbers honest, and the internal-vs-external sourcing rules for decks and memos. Use when asked check the sourcing in this deck, add citations to this doc, our slide says 'studies show' — which studies, or set citation norms for the team. Produces the claim-by-claim audit, the fixes (source found, claim softened, or cut), the citation format for the venue, and the team norm card.

Start a cross-team project with the collaboration contract that prevents the classic collisions — who decides what, how work flows between teams, the communication channels and cadence, and what done means — agreed before the first collision instead of during it. Use when asked kick off this cross-team project right, our two teams keep colliding, define how we'll work with the other team, or set up the partnership before we start. Produces the one-page contract: decision rights, interfaces, cadence, and the done-definition.

Run a company event — the launch party, the customer day, the team celebration — as the operation it is: the goal that shapes every choice, the budget with its forgotten lines, the vendor and venue coordination, the run-of-show with owners, and the day-of roles that keep hosts hosting. Use when asked plan the company event, organize our customer day/holiday party/launch event, what am I forgetting for this event, or be the run-of-show for Thursday. Produces the goal-shaped plan, the budget with the forgotten lines, the run-of-show, and the day-of role card.

Run a fast, honest competitive scan — the dimension table built from public evidence (sites, docs, pricing pages, changelogs, reviews), the claims-vs-observed discipline, and the so-what synthesis that ends in moves, not a landscape mural. Use when asked what are competitors doing, quick scan of these three rivals, how does our pricing/feature set compare, or prep the competitive slide honestly. Produces the evidence-based comparison table, the marketing-vs-reality flags, the so-what synthesis, and the staleness date.

Treat context switches as the budget line they are — the switch census (how fragmented the week really is), the batching moves that consolidate scattered same-kind work, the calendar defrag that turns Swiss cheese into slabs, and the switch-cost line for saying no. Use when asked my day is fragmented to death, count my context switches, batch my meetings and reviews, or defend against calendar Swiss cheese. Produces the fragmentation census, the batching plan, the defrag moves, and the protective phrases.

Never get auto-renewed into another year again — the contract inventory with the dates that matter (notice deadlines, not renewal dates), the calendar system with decision-time buffers, and the renewal-decision ritual that renegotiates instead of rubber-stamping. Use when asked track our contracts and renewals, we got auto-renewed again, when do we have to decide on this vendor, or set up renewal management. Produces the inventory with notice-deadline math, the alert system, the renewal-decision checklist, and the negotiation-window playbook.

Clean a messy dataset methodically — the profiling pass that finds what's actually wrong (dupes, format drift, phantom spaces, mixed types), the fix order that doesn't corrupt while correcting, and the log that makes the cleaning defensible. Use when asked clean this export, why is my pivot double-counting, these names don't match between sheets, or prep this data for analysis. Produces the profile of what's wrong, the ordered cleaning plan, the join-key repairs, and the cleaning log.

Design slides where the data makes the argument — the takeaway-titled chart, the one-chart-per-slide rule, the annotation layer that guides the eye to the point, and the honesty pass on projected data. Use when asked make this data slide land, my chart slide confuses people, how do I present these numbers, or the audience missed the point of my graph. Produces the redesigned slide: takeaway title, the chart stripped and annotated, the eye-path check, and the honesty audit.

Set up the team decision log that ends relitigation — the one-line-per-decision format (what, why, who, when, reopening rule), the capture moments wired into existing rituals, and the lookup habit that makes it pay. Use when asked set up a decision log, we keep re-deciding the same things, where do decisions get recorded, or new people keep asking why we do X. Produces the log format, the capture wiring, the reopening rule, and the retrieval habits.

Run meetings that actually decide — the pre-read-then-decide format, the options-on-the-table rule, the decider named before debate starts, and the recorded-or-it-didn't-happen close. Use when asked run this decision meeting, we discuss forever and never decide, structure the meeting where we pick the vendor/plan/design, or why do our decisions get relitigated. Produces the meeting design: pre-read, the in-room sequence, the decision rule, and the recording that makes it stick.

Give a deck a spine the room can follow — the situation-complication-resolution arc, the tension that makes the recommendation feel necessary, the transitions that carry the thread between slides, and the arc-check that catches sag. Use when asked make this deck flow, my presentation feels like disconnected slides, structure the story of this pitch/readout, or the room got lost in the middle. Produces the arc mapping, the tension line, the transition script, and the sag diagnosis.

Outline a deck as headline sentences before opening the slide tool — each slide a claim that reads as an argument top to bottom, the audience-and-ask header, and the skim test that catches broken decks while they're still bullet points. Use when asked start this presentation, structure my deck, why does my deck feel like a data tour, or get sign-off before I build slides. Produces the headline outline, the per-slide evidence notes, the skim test result, and the build rules.

Review a deck against a rubric instead of taste — the five dimensions (argument, evidence, density, arc, honesty), the severity-sorted feedback that separates broken from suboptimal, and the review conversation that improves the deck without rewriting it in the reviewer's voice. Use when asked review my deck, give feedback on this presentation, is this ready for the board, or our deck reviews are just font opinions. Produces the rubric scores with evidence, the severity-sorted feedback, the two-fixes-that-matter-most call, and the reviewer discipline notes.

Protect focus time that actually survives the week — the block placement matched to real energy hours, the defense rules (what moves a block, what never), the entry ritual that beats the blank-stare start, and the honest sizing that stops 8-hour fantasy blocks. Use when asked block focus time that keeps getting eaten, when should I schedule deep work, my calendar has no room to think, or I block time and then waste it. Produces the block design, the defense tiers, the entry ritual, and the meeting-culture negotiation.

Delegate so the work comes back right the first time — the brief that transfers outcome, context, and constraints (not just the task), the autonomy level stated explicitly, and the check-in design that catches drift without hovering. Use when asked hand this off properly, my delegations come back wrong, write a brief for this task I'm giving away, or how much detail do I give. Produces the delegation brief with the outcome and guardrails, the autonomy level, the check-in points, and the questions-welcome contract.

Script a product demo that lands — the audience's-workflow storyline (their day, not your feature list), the golden path rehearsed with fallbacks, the wow moment placed early, and the demo-death contingencies (the backup video, the reset state, the narration bridge). Use when asked script our product demo, demo this to a customer/exec, our demos meander through features, or the demo broke live last time. Produces the demo storyline, the click-path script with fallbacks, the wow placement, and the contingency kit.

Run a timeboxed desk-research sprint that ends with an answer instead of forty tabs — the question decomposition, the source plan by question type, the capture discipline that prevents re-reading, and the stop rule that beats completionism. Use when asked research this market/tool/topic by Friday, I have two hours to get smart on X, structure my desk research, or I keep researching and never concluding. Produces the decomposed questions, the source plan, the capture format, and the timeboxed synthesis with confidence labels.

Clear the desktop that's become a hundred-icon guilt mosaic — the fast triage that empties it today, the honest read of what the desktop was being used for (it's a to-do list wearing icons), and the replacement systems that keep it clear. Use when asked clean up my desktop, my desktop has 200 files on it, why does my desktop keep filling up, or set up a clean-desktop habit. Produces the today-pass, the function-replacement mapping, and the two-minute weekly habit.

Keep living documents trustworthy over time — the status header (draft/active/superseded) that tells readers what they're holding, the change-log-for-decisions inside the doc, the supersession chain that kills zombie versions, and the review-date heartbeat. Use when asked which version of this doc is current, our wiki is full of stale pages, set up doc lifecycle rules, or people keep following the old process doc. Produces the status-header standard, the in-doc change log, the supersession protocol, and the staleness heartbeat.

Decide what documents to keep, for how long, and where — the personal/small-biz retention map by category (tax, legal, medical, warranties, employment), jurisdiction-flagged periods, and the destruction discipline for what's past its date. Use when asked how long do I keep tax documents, can I shred this, set up a document retention system, or what papers does my small business need to keep. Produces the category map with keep-periods (flagged verify-locally), the keep-forever list, the digitize rules, and the annual purge ritual.

Make introductions that respect both sides — the double-opt-in flow (ask each party privately before connecting them), the forwardable blurb that makes saying yes easy, and the connecting email that sets both up to succeed. Use when asked introduce me to someone, can you connect us, write an intro email, or someone asked me for an intro. Produces the opt-in asks for both sides, the forwardable blurb, the intro email itself, and the graceful decline path.

Empty the Downloads folder that's become a junk drawer — the four-bucket pass (file, delete, action, quarantine), the age-based bulk rules that make 2,000 items tractable, and the tiny habit that keeps it empty. Use when asked clean up my downloads folder, 2000 files in downloads help, what's safe to delete here, or stop my downloads from piling up. Produces the bucket pass with bulk rules, the safe-delete classes, the keeper-filing routes, and the weekly sweep habit.

Convert an email (or a whole thread) into real tasks — the actual asks extracted from the prose, each with owner, deadline, and the done-test, so nothing lives in the inbox as its own reminder. Use when asked what am I actually being asked to do here, turn this thread into a task list, extract the action items from this email, or I keep re-reading this thread. Produces the ask extraction with quoted sources, the task list in owner-verb-deadline form, and the reply that confirms the commitments.

Turn an overflowing inbox into a four-verb system — archive, reply-now, task, or park — with the two-minute rule enforced and a daily cadence that survives busy weeks. Use when asked help me get to inbox zero, my email is out of control, build me an email triage system, or process this backlog. Produces the triage pass on the actual inbox, the four-verb rules, the folder/label minimal set, and the daily cadence.

Schedule work by energy, not just time — the week of self-observation that maps your real peaks and troughs, the work-to-energy matching (hard creative work on peaks, admin on slopes, meetings on shoulders), and the calendar rebuild that honors the map. Use when asked when should I do my hardest work, I waste my best hours on email, map my energy levels, or why is 3pm always useless. Produces the observation protocol, the personal energy map, the work-type matching, and the rebuilt week.

Escalate an issue up the chain without burning the person you're escalating past — the facts-first structure, the tried-already section that earns the escalation, and the specific ask that makes action easy. Use when asked I need to escalate this, write an email to my boss's boss, this vendor issue needs to go up, or how do I go over someone's head professionally. Produces the escalation email with its evidence spine, the pre-escalation courtesy step, and the relationship-preserving framing.

Grade the evidence behind a claim before betting on it — the hierarchy for business evidence (experiments > usage data > surveys > interviews > anecdotes > opinion), the fit-for-decision test, and the mixed-evidence verdicts that real questions produce. Use when asked how strong is our evidence for this, grade what we know before the decision, is this enough to bet on, or we have three anecdotes and a survey — now what. Produces the evidence inventory with grades, the sufficiency verdict against the decision's stakes, and the cheapest-upgrade path.

Stop presenting the working deck to executives — the two-deck split (answer-first exec cut vs. exploration-rich working deck), the compression rules from 40 slides to 8, and the appendix strategy that keeps the depth one click away. Use when asked turn this analysis into an exec version, my leadership readout went badly, how do I compress 40 slides to 10 minutes, or what do execs actually want in a deck. Produces the exec cut with the answer-first order, the compression map (what survived, where the rest went), and the Q&A appendix plan.

Submit expenses that sail through approval — the capture-at-spend habit, the policy-fluency that prevents rejections (thresholds, receipt rules, the pre-approval traps), the report assembled in minutes, and the approver-side rules for reviewing fairly and fast. Use when asked my expense reports are always late or rejected, set up my expense workflow, what does the policy actually require, or review expenses as a manager without being a receipt cop. Produces the capture habit, the policy crib, the submission routine, and the approver's rubric.

Design an expense-tracking sheet that survives real receipts — the capture-at-spend habit, the category set that matches reimbursement or tax rules, the receipt-link discipline, and the month-end close that takes minutes because the work happened at spend-time. Use when asked track my business expenses, build an expense sheet for the team, get ready for reimbursement/tax season, or my shoebox of receipts needs a system. Produces the sheet structure, the capture ritual, the category mapping to the real downstream rules, and the month-end close.

Get the most from an hour with an expert — the do-your-homework floor (never ask what's googleable), the question arc from calibration to the frontier, the follow-up discipline that goes deep instead of wide, and the capture that survives the call. Use when asked prep me for the expert call, what should I ask this advisor/analyst/practitioner, we get an hour with X, or our expert calls are pleasant but shallow. Produces the homework brief, the question arc, the follow-up toolkit, and the capture plan.

Build an FAQ from the questions people actually ask — mined from tickets, chats, and repeated explanations, answered once and well, organized by the asker's words, and maintained by a capture loop instead of annual archaeology. Use when asked create an FAQ for this product/process/team, I answer the same questions weekly, turn our support threads into docs, or why does nobody find our answers. Produces the mined question list with frequencies, the answers in ask-language, the structure, and the capture loop.

Set a filename convention that sorts, searches, and survives — date-first ISO format, the descriptor grammar, version suffixes that end the FINAL-final2 era, and the rollout that gets a team actually using it. Use when asked set up file naming rules, our filenames are chaos, what should we call our files, or fix the v2-final-FINAL problem. Produces the convention with its grammar, examples for the team's real file types, the version rule, and the one-line cheat sheet.

Design a folder structure people actually file into — shallow, purpose-first, with a home for everything and an inbox for the undecided, sized to the team that must maintain it. Use when asked organize our shared drive, design a folder structure for the project, where should things live, or our files are chaos. Produces the structure with its placement rules, the depth and naming constraints, the _inbox convention, and the migration-lite plan for the existing mess.

Chase unanswered emails without being annoying — the escalating-gently sequence with timing rules, the re-ask that makes replying easy, and the close-the-loop discipline that ends zombie threads. Use when asked they haven't replied what do I send, write a follow-up that isn't pushy, how long do I wait before chasing, or manage my waiting-on list. Produces the follow-up sequence with dates, drafts per rung, and the give-up-gracefully exit.

Untangle the spreadsheet formula nobody dares touch — decompose the seven-function nest into named readable steps, explain what it actually does (vs. what it's believed to do), and rebuild it maintainably with helper columns and modern functions. Use when asked what does this formula do, this IFERROR-VLOOKUP monster broke, make this formula maintainable, or nobody understands the sheet the analyst left. Produces the plain-language decode, the step decomposition into helper columns, the believed-vs-actual gaps, and the rebuilt version.

Write the handbook page that ends the repeated explanation — the answer-shaped structure (task-first, context second), the ownership and freshness header, and the write-once-point-forever discipline that turns tribal knowledge into infrastructure. Use when asked document how we do X, write the wiki page for this process, I explain this every month, or make this knowledge survive me. Produces the page with task-first structure, the header block, the worked example, and the pointer habit.

Apply a team's writing style consistently — extract the house style from exemplar documents into a checkable rule card, run the conformance pass on new drafts, and fix violations without flattening the author's voice. Use when asked make this match our style, why do our docs all sound different, build a style guide from our best docs, or check this draft against house style. Produces the extracted rule card, the conformance pass with per-fix reasons, and the voice-preservation line.

Cut inbox volume at the source — the unsubscribe purge that classifies recurring senders into kill/digest/keep, executes safely (real unsubscribes vs. spam-report vs. never-click), and installs the filters that catch the rest. Use when asked my inbox is all newsletters, mass unsubscribe safely, cut my email volume, or set up filters for the noise. Produces the sender census, the kill/digest/keep sort, the safe-unsubscribe rules, and the filter set.

Turn a pile of interview notes into findings that survive scrutiny — the code-then-theme pass, the counting discipline (how many actually said it), the quote selection that illustrates instead of cherry-picks, and the confidence lines a small sample earns. Use when asked synthesize these user/customer/exit interviews, what did we actually learn from the calls, turn 12 transcripts into insights, or are these themes real. Produces the coded themes with counts, the divergences preserved, the illustrative quotes, and the claims sized to the sample.