How interactive, AI-powered surfaces are replacing the static files that slow decisions down—plus 12 quick-start prompts to build your own executable artifacts today!
Nate
Work is changing, and we need to talk about it.
No, I don’t mean the jobs thing! Everyone writes about AI and jobs all the time (and sometimes I do too). Today I want to call out that how we work is changing fast, and we don’t have the vocabulary for it. We need to talk about a new way of working that’s AI native.
I've been building products for fifteen years. In that time, I've watched us digitize everything except the actual work of making decisions. We moved from paper to pixels, from filing cabinets to cloud storage, from conference rooms to Zoom. But we're still making decisions the same way we did in 1995: gathering data, making slides, having meetings, following up with more slides.
Last month, I watched a brilliant engineering team spend two weeks preparing for a launch review that should have taken thirty minutes. They knew they were ready to ship. Everyone knew it. But they needed the ritual—the deck, the appendix, the backup slides no one would read. They needed permission to trust their own judgment.
That's when it hit me: AI hasn't just given us better tools. It's given us the ability to completely reimagine how decisions get made.
What follows is the most important piece I've written about the future of work. It's not about AI taking jobs or making us more creative. It's about replacing the entire operating system of how organizations function—moving from static documents to living instruments that make decisions executable, auditable, and fast.
I'm going to show you exactly how to build these instruments. Not in theory—with actual prompts you can use today. Twelve complete examples covering everything from weekly business reviews to launch gates to customer health scoring.
This isn't speculation. These patterns are emerging right now at companies you know. The question isn't whether this shift will happen. It's whether you'll be ahead of it or behind it.
Let me show you how to get ahead.
Subscribers get all these newsletters!
Subscribed
From Documents to Instruments: A New Operating Surface for Work
=================================================================
Interactive artifacts are replacing static deliverables. The implications run deeper than you think.
We're witnessing a fundamental shift in how work gets done. ChatGPT-5, Claude, Gemini—they're all converging on the same capability: transforming conversations into executable artifacts that make decisions fast, auditable, and final.
This isn't about AI replacing jobs. It's about replacing the bureaucratic sludge that makes our jobs miserable.
The real bottleneck in modern companies isn't creativity. AI solved that problem two years ago. Need 100 ideas? Done. The real drag is the cost of proving a decision. We burn weeks turning data into spreadsheets, spreadsheets into slides, slides into meetings, meetings into more slides.
Now chats are becoming all three—docs, spreadsheets, and slides—instantly. But we're still bolting our old decision-making processes onto this new capability. We're missing the bigger opportunity.
The Threshold We Just Crossed
With ChatGPT-5's canvas feature reaching 700 million users, we've crossed a critical threshold. For the first time, non-coders can create interactive artifacts that collapse entire decision chains into single, executable moments.
These aren't documents. They're instruments—front-end artifacts with typed inputs, live logic, embedded tests, and clean outputs. Run them, capture the decision, move on.
A good instrument replaces several meetings and a deck with one surface and one decision. No follow-ups. No "let me get back to you." No death by PowerPoint.
Four factors make this possible now:
Distribution is solved. Single-file canvases travel as easily as slides. Share a ChatGPT or Claude artifact with a link. No infrastructure. No deployment. It just works.
Cost approaches zero. Your team already has ChatGPT or Claude subscriptions. The canvas comes free. No procurement. No IT approval. No additional budget.
Governance is embedded. Tests and approvals live in the instrument itself. The audit trail isn't in some separate system—it's right there in the artifact. Screenshot it if you need to lock it down.
Improvements compound. These artifacts aren't static. They're living. Each week's business review instrument gets better than the last. Edge cases get captured. Tests get refined. Knowledge accumulates.
Anatomy of an Instrument
An instrument isn't just a dashboard or a form. It has six essential components:
Typed inputs with explicit schemas. Not free text fields—structured data with validation. Numbers are numbers. Dates are ISO-8601. Percentages are 0-1 scale. No ambiguity.
Visible logic you can inspect and test. The code is right there. You can see exactly how decisions are calculated, what thresholds matter, which edge cases are handled.
Minimal UI with clear affordances. A scoreboard display with a few critical knobs. Present mode for meetings. What-if sliders for scenarios. Not 50 options—just the ones that matter.
Tests as gates. Red blocks don't export. If data quality is bad, it stops. If required approvals are missing, it stops. If thresholds are breached, it alerts. The policy is the code.
Built-in audit trail. Every run captures who, what, when, and why. Changes are tracked. Assumptions are explicit. Six months later, you can reconstruct exactly why a decision was made.
Clean exports in JSON and Markdown. The decision record that satisfies compliance, feeds downstream systems, and goes into the permanent file.
Take these components seriously. An instrument without an audit trail is just a calculator. An instrument without tests is just a dashboard. The power comes from the complete package.
How Work Actually Changes
When you start running meetings inside instruments, everything shifts.
The instrument becomes the agenda, the analysis, the gate, and the record simultaneously. If it isn't in the instrument, it didn't happen. No more "I think we decided X but let me check my notes." The decision is encoded.
Tests come first, not last. Thresholds and approvals aren't guidelines—they're code. A launch either passes the readiness gate or it doesn't. A deal either meets margin requirements or it doesn't. The instrument won't let you proceed with a failed test.
Policy becomes code. Legal publishes rule versions the artifact enforces. Risk sets thresholds the instrument checks. Finance defines margin floors that block non-compliant deals. Changing policy means changing tests and releasing a new version.
Leaders have to model the behavior. Ask for the instrument, not the slide. Tweak assumptions live in the meeting. When the VP stops accepting PowerPoints and starts demanding instruments, the culture shifts.
Operators own outcomes. The sales leader owns the deal desk instrument. The engineering lead owns the launch gate. The finance lead owns the pricing simulator. They're accountable for the verdicts their instruments produce.
Evidence becomes free. Every decision is reproducible. Baselines, hashes, and exports eliminate the separate "board pack." When someone asks "why did we make that call?" you pull up the exact instrument with the exact inputs.
The Real Challenge: Culture, Not Technology
Building these instruments is technically straightforward. ChatGPT and Claude can generate them from prompts. The real challenges are cultural.
Over-trust is dangerous. People see numbers in a dashboard and assume they're correct. But garbage in still means garbage out. You need visible assumptions, upstream data quality checks, and clear failure modes.
Sprawl kills adoption. Without discipline, you get 50 versions of the same artifact. One team's WBR looks nothing like another's. Trust erodes. You need naming conventions, version control, and someone who owns convergence.
Instruments can narrow thinking. When every pricing decision runs through the same simulator, it's easy to stop questioning the underlying model. You need deliberate processes for challenging the instruments themselves.
The solution isn't to avoid instruments. It's to manage them like any critical business process.
Making the Transition Stick
Stand up an Instrument Studio—a small team of design, frontend, and data people who maintain standards. They don't build every instrument. They maintain schemas, testing patterns, export formats, and quality bars that let everyone else build.
Assign policy stewards to each instrument class. Legal owns the contract risk triage rules. Finance owns the deal desk thresholds. The steward owns the rules, not the ceremony.
Change your incentive structure. Stop rewarding presentations delivered. Start rewarding decisions shipped through gates. Track cycle time from question to decision. Measure the percentage of decisions with clear audit trails.
Map instruments to your operating cadence. Weekly business reviews, launch readiness, incident response, pricing reviews, customer health checks—each gets its own instrument pattern. Consistency builds trust.
Start with experimentation but drive toward convergence. Let teams try different approaches initially, then pick winners and standardize. The AWS team's launch gate becomes the launch gate. The sales team's deal desk becomes the deal desk.
Manage versions aggressively. Instruments have owners, semantic versioning, and deprecation schedules. Old versions get sunset. New versions get release notes. This isn't chaos—it's managed evolution.
The Platform Opportunity
If you're building tools—Word, Docs, Notion, Sheets—your product is no longer a document editor. It's an execution surface.
The winners will ship primitives for instruments: typed input blocks, logic components, test gates, audit trails, and stable export formats. "Run" becomes as important as "Edit" or "Comment." The entire flow of "Run → Record → Share" should be one gesture.
Distribution and safety become your moat. Single-file artifacts that run sandboxed in browsers. No infrastructure setup. Deterministic, inspectable logic with clear separation between inputs, generated code, and evaluation.
Value accrues at runtime, not authoring time. It doesn't matter who writes the best PRD. It matters whose instrument produces the clearest decision fastest. Price on active instruments, certified runs, and governed seats—not document storage.
Policy as code becomes a platform primitive. Rule DSLs, versioned tests, approval workflows, and compliance certificates. The ability to say "this decision passed version 2.1.3 of our margin policy" and prove it.
12 Instruments
I've created a dozen instruments that work together as a coherent operating system. Each includes a complete prompt you can paste into ChatGPT or Claude today.
Run the Business
- WBR Scorecard: 8-week trending with sparklines, channel mix, and anomaly detection
- Data Quality Sentinel: Freshness monitoring, null checks, duplicate detection, drift alerts
Ship Decisions
- Experiment Decision Pad: Statistical significance, guardrail checks, power analysis
- Launch Readiness Gate: Multi-function go/no-go with evidence requirements
Manage Reliability
- Incident Commander Board: Real-time incident tracking, MTTR calculation, action assignment
- Support SLA Radar: Response time heatmaps, breach tracking, escalation paths
Control Revenue & Risk
- Deal Desk Guard: Margin validation, discount approval, terms compliance
- Contract Risk Triage: Automated review for NDAs, MSAs, and DPAs
Optimize Customers
- Customer Health Triage: Multi-signal scoring, churn prediction, intervention triggers
- Pricing & Mix Simulator: Elasticity modeling, channel optimization, scenario planning
Scale People
- Hiring Funnel Health: Conversion tracking, source effectiveness, time-to-fill analysis
- Access Review Runner: SoD detection, orphaned accounts, stale permission cleanup
These aren't templates. They're working instruments. Customize them. Remix them. Make them yours. The prompts are opinionated about structure but flexible about implementation.
The Strategic Bet
We're moving the center of gravity from narrative to execution. Instruments don't kill documents—they demote them. Docs capture context. Instruments produce decisions.
This isn't about small productivity gains. Companies that figure this out will operate at a fundamentally different clock speed. While competitors schedule follow-ups to review last week's analysis, these companies will have run three instruments, made five decisions, and moved to the next problem.
The technology is here. The patterns are proven. The only question is whether you'll start using them.
Pick one decision that currently requires a deck. Replace it with an instrument this week. Run your next meeting inside the artifact. Capture the decision. Move on.
Then do it again.
Welcome to the new operating surface of work. We're all going to figure it out together.
12 corrected build prompts
================================
The complete prompts for all 12 instruments follow below. Copy them into ChatGPT-5 or Claude, customize for your needs, and start running your business at the speed of conversation.
1) WBR — Scoreboard
Build a single-file React + Tailwind "WBR — Runnable Document".
Brief:
- 8-week scoreboard with WoW deltas, sparklines, channel mix. Inline edits. Display-first; no external data.
Inputs:
- weeks[8]: {
endISO:string,
kpi:{ revenue:number, orders:number, active:number, cac:number },
channels: Record<"paid"|"organic"|"email"|"referral", number>
}
- channelMetric: "revenue"|"orders"|"sessions"
- alertThreshold:number (0.05–0.30)
- logicVersion:string
UI:
- KPI cards (Revenue, Orders, Active, CAC) with WoW (invert CAC).
- **Delta rule:** if last==0 → delta=null; render "—" (don’t mask step-changes).
- Sparklines across 8 weeks.
- Channel table (This vs Last, WoW, Share) labeled with channelMetric.
- History Editor (edit all 8 weeks), Present mode.
- Copy Markdown/JSON. Tests Gate at top.
Logic:
- WoW = (this-last)/last; CAC uses invert flag.
- Anomalies = |WoW| ≥ alertThreshold.
Tests:
- All week.kpi finite across 8 weeks.
- channelMetric provided; channel values finite; sum(channels) > 0.
- WoW math finite where last>0; if last==0 → delta=null and UI shows "—".
Audit/Export:
- docId + canonicalized hash of {weeks.kpi, channels, channelMetric, alertThreshold, logicVersion}.
- Persist baseline/lastRun in localStorage.I created a sample for this first example to give you an idea how it works!
2) Experiment Decision Pad
Build "Experiment Decision Pad — Runnable Document" (single-file React + Tailwind).
Brief:
- Decide Ship/Hold for an A/B test using lift, CI, power, and guardrails mapped to risk appetite.
Inputs:
- traffic:{
A:{ users:number, convCount:number, revenuePerUser:number },
B:{ users:number, convCount:number, revenuePerUser:number }
}
- priors:{ mde:number, riskAppetite:"low"|"medium"|"high" } // mde as fractional lift
- observed:{ bounceRate:number, p95LatencyMs:number, churnLift:number }
- guardrailThresholds:{ bounceMax:number, p95LatencyMaxMs:number, churnLiftMax:number }
- riskPolicy:{
low:{ allowMinorBreaches:number },
medium:{ allowMinorBreaches:number },
high:{ allowMinorBreaches:number }
}
- logicVersion:string
UI:
- Inputs left; Decision right: convRate, lift, **Wilson/Agresti–Coull CI** (pick one), power vs MDE.
- Guardrails with PASS/FAIL; "minor" breach if within 10% of threshold.
- What-if sliders: users and expected lift. Tests Gate at top.
Logic:
- convRate = convCount/users; lift = (rB-rA)/rA.
- Decision PASS if CI excludes 0 and guardrail breaches ≤ riskPolicy[riskAppetite].allowMinorBreaches.
Tests:
- users, convCount ≥ 0; **revenuePerUser ≥ 0**.
- Sample ratio sanity: |A.users - B.users|/(A.users+B.users) ≤ 0.02.
- CI finite; power computed.
Audit/Export:
- Show inputs, CI/power method, appetite mapping.
- Canonicalized hash (exclude generatedAtISO). Persist baseline.3) Launch Readiness Gate
Build "Launch Readiness Gate — Runnable Document" (React + Tailwind, single file).
Inputs:
- sections: Array<{
name:"Perf"|"Docs"|"Runbooks"|"Support"|"Legal"|"Risk",
items: Array<{ title, owner, link?, evidenceStatus:"present"|"missing", thresholdMet:boolean }>
}>
- rollout:{ blastRadius:string, stagedRollout:boolean, rollbackPlan:boolean, oncall:boolean }
- approvals: Array<{ role, name, approved:boolean, approvedAtISO?:string }>
- requiredRoles:string[] // approvals must include these roles with approved=true
- sevScaleNote?:string
- logicVersion:string
Logic:
- GO only if all items thresholdMet && evidenceStatus="present", rollout.oncall && rollbackPlan true, and **approvalsComplete** where every role in requiredRoles has approved=true.
Tests:
- Required sections exist; valid URL format for links.
- Any threshold false → NO-GO.
Audit/Export:
- Diff of missing→present evidence; approvals summary.
- Canonicalized hash; persist baseline.4) Incident Commander Board
Build "Incident Commander Board — Runnable Document" (single-file React + Tailwind).
Inputs:
- slos: Array<{ name, target:number, window:string, current:number }>
- incidents: Array<{
id:string, startISO:string, endISO?:string,
sev:0|1|2|3, service:string, impactNote:string, customerFacing:boolean,
ic:string, // assignee linkage
assignees?:{ comms?:string }
}>
- actions: Array<{ id:string, incidentId:string, owner:string, dueISO:string, status:"open"|"done" }>
- roster:{ fallbackIC:string, oncall:string }
- logicVersion:string
Logic:
- MTTR = (endISO ?? now) - startISO.
- SLO miss if current < target.
- Post-mortem required if sev≥2 OR any SLO miss.
Tests:
- **Every active incident (no endISO) has `ic`** (or fallbackIC applied visibly).
- **For sev≥2:** there exists **actions.some(a => a.incidentId===incident.id && a.status==="open")**.
- If customerFacing=true → comms owner present (incident.assignees.comms or an action tagged "comms").
Audit/Export:
- Close-out MD with timeline, MTTR, linked actions.
- Canonicalized hash; persist baseline.5) Customer Health Triage
Build "Customer Health Triage — Runnable Document" (React + Tailwind, single file).
Inputs:
- accounts: Array<{
name, arr:number, segment:"ent"|"mm"|"smb",
startDateISO:string, renewalDateISO:string,
usage7d:number, usage28d:number, tickets30d:number, nps:number,
owner:string
}>
- weights:{ usage:number, tickets:number, nps:number, tenure:number }
- logicVersion:string
Logic:
- tenureMonths = monthsBetween(now, startDateISO).
- Health score = weighted z-sum (+usage28d, -tickets30d, +nps, +tenure).
- **Fallback scaling:** if accounts.length < 8, use min-max per driver.
- Next-best actions keyed by dominant driver.
Tests:
- Every account has owner.
- Scores finite; ARR-weighted low-score accounts flagged.
- Renewal within 60d & low score → P1 follow-up.
Audit/Export:
- Tier movements; canonicalized hash; persist baseline.6) Deal Desk Guard
Build "Deal Desk Guard — Runnable Document" (single-file React + Tailwind).
Inputs:
- quote:{ acv:number, discountPct:number, termMonths:number,
payment:"prepay"|"net30"|"net60", cogsPct:number,
nonStandardTerms:string[] }
- policy:{ marginFloorPct:number, maxDiscountPct:number,
allowedPayments:string[], requiresLegalForTerms:string[] }
- logicVersion:string
Logic:
- netPrice = acv * (1 - discountPct)
- marginPct = 1 - discountPct - cogsPct
- PASS iff marginPct ≥ marginFloorPct, discountPct ≤ maxDiscountPct, payment ∈ allowedPayments, and legal approvals for any required term.
- **Escalation:** if termMonths>12 AND discountPct > 0.8*maxDiscountPct → flag "CFO review" even if PASS.
Tests:
- acv>0; 0≤discountPct<0.9; termMonths>0.
- Legal required when terms intersect requiresLegalForTerms.
Audit/Export:
- Approvals & rationale; canonicalized hash; persist baseline.7) Pricing & Mix Simulator
Build "Pricing & Mix Simulator — Runnable Document" (React + Tailwind, single file).
Inputs:
- basePrice:number, price:number, baseDemand:number,
- elasticity:number // UI slider clamped to [-5, +1] with label: typical negative
- channelMix:{ direct:number, partner:number, paid:number } // sum≈1
- unitCost:number, fixedCost:number
- constraints:{ minPrice:number, maxPrice:number, minMixPerChannel:number }
- scenarios?: Array<{ name, snapshot:any }>
- logicVersion:string
Logic:
- demand = baseDemand * (price/basePrice) ^ elasticity
- revenue = price * demand
- variableCost = unitCost * demand
- profit = revenue - variableCost - fixedCost
- Normalize channelMix live; show normalized values.
Tests:
- |direct+partner+paid - 1| ≤ 0.001; each ≥ minMixPerChannel.
- constraints respected; baseline profit non-negative.
Audit/Export:
- Scenario diff; canonicalized hash; persist baseline.8) Contract Risk Triage
Build "Contract Risk Triage — Runnable Document" (single-file React + Tailwind).
Inputs:
- text:string, type:"NDA"|"MSA"|"DPA"|"SLA",
- prefs:{ govLaw:string, riskAppetite:"low"|"medium"|"high" }
- ruleWeights:{ high:number, medium:number, low:number } // e.g., 3/2/1
- appetiteThresholds:{ low:number, medium:number, high:number }
- logicVersion:string
Logic:
- Normalize prefs.govLaw (trim/case).
- Regex rules: governing-law match, indemnity mutual/scope, liability cap+exclusions, cure period, DPA reference, assignment on change of control, security/audit.
- penalty = Σ failed rule weights; PASS if penalty ≤ appetiteThresholds[riskAppetite].
- **Banner disclaimer:** “Policy triage, not legal advice.”
Tests:
- Non-empty text; for MSA/DPA, both cap & exclusions required to PASS.
- Appetite thresholds respected.
Audit/Export:
- New vs resolved issues; canonicalized hash; persist baseline.9) Data Quality Sentinel
Build "Data Quality Sentinel — Runnable Document" (React + Tailwind, single file).
Inputs:
- tables: Array<{
name, freshnessSLAmins:number, lastLoadedISO:string,
rowCount:number, nullRatePct:number, pkDupPct:number,
hasPK:boolean, dupCheckDisabled?:{ reason:string },
driftBaseline?:{ rowCount:number, nullRatePct:number }
}>
- thresholds:{ maxNullPct:number, maxDupPct:number }
- logicVersion:string
Logic:
- Freshness = (now - lastLoadedISO) ≤ freshnessSLAmins.
- Null/dup within thresholds (skip dup check if dupCheckDisabled present).
- Drift (optional): flag if |rowCountΔ|≥0.2 or |nullΔ|≥0.05.
- Surface timezone note in UI (parse lastLoadedISO).
Tests:
- lastLoadedISO parseable; each table has hasPK==true OR dupCheckDisabled.reason present.
- Any FAIL blocks export; muted checks listed with rationale.
Audit/Export:
- Checklist with failures/mutes; canonicalized hash; persist baseline.10) Access Review Runner
Build "Access Review Runner — Runnable Document" (single-file React + Tailwind).
Inputs:
- users: Array<{ name, manager, roles:string[], systems:string[], lastLoginISO:string, criticalAccess:boolean }>
- policies:{ SoDConflicts: Array<[string,string]> }
- logicVersion:string
Logic:
- Orphaned if manager missing.
- SoD conflict if user has both roles in any policy pair.
- Stale if now - lastLoginISO > 90d.
Tests:
- All criticalAccess reviewed (attest/revoke/comment) before “Complete”.
- No unresolved SoD conflicts at close.
Audit/Export:
- Capture reviewer {name, role} at export time.
- Canonicalized hash; persist baseline.11) Hiring Funnel Health
Build "Hiring Funnel Health — Runnable Document" (React + Tailwind, single file).
Inputs:
- pipeline: Array<{
role, owner,
stageCounts:{ applied:number, phone:number, onsite:number, offer:number },
agingDaysPerStage:{ applied:number, phone:number, onsite:number, offer:number },
sourceMix: Record<string, number> // fractions, should sum≈1
}>
- targets:{ conversionByStage: Record<"applied→phone"|"phone→onsite"|"onsite→offer", number>, responseSLAhrs:number }
- logicVersion:string
Logic:
- Conversion = consecutive stage ratios vs targets.
- timeToFillDays = sum(agingDaysPerStage[stage]).
- Highlight **top source** contributor per role.
Tests:
- Monotonic counts (applied ≥ phone ≥ onsite ≥ offer).
- |sum(sourceMix) - 1| ≤ 0.001; flag missing owners and SLA breaches.
Audit/Export:
- Diff in conversions vs last run; canonicalized hash; persist baseline.12) Support SLA Radar
Build "Support SLA Radar — Runnable Document" (single-file React + Tailwind).
Inputs:
- tickets: Array<{
id, priority:"P1"|"P2"|"P3", status:"open"|"pending"|"resolved",
openedISO:string, firstResponseISO?:string, resolvedISO?:string,
lastUpdateISO:string, owner:string, csat?:number, postmortemNote?:string
}>
- sla:{
P1:{ firstRespMins:number, resolveHrs:number },
P2:{ firstRespMins:number, resolveHrs:number },
P3:{ firstRespMins:number, resolveHrs:number }
}
- logicVersion:string
Logic:
- tFirst = (firstResponseISO ?? now) - openedISO.
- tResolve = (resolvedISO ?? now) - openedISO.
- **Heatmap buckets (first-response):** <1h, 1–4h, 4–24h, >24h.
**Resolution buckets:** <4h, 4–24h, 1–3d, >3d.
Tests:
- P1 breached & status="resolved" → require non-empty postmortemNote to close.
- No orphaned tickets (owner required).
- “All green” only if no active breaches.
Audit/Export:
- JSON/MD summary: breaches, owners, CSAT trend; canonicalized hash; persist baseline.Start Today
These 12 instruments are just the beginning. They're not perfect. They're not complete. But they give you a starting point, and that's what matters.
The shift from documents to instruments isn't coming—it's here. Every week you wait is another week of unnecessary meetings, redundant analysis, and delayed decisions. Every deck you create is time you could have spent running an instrument and moving to the next problem.
Start small. Pick the decision that annoys you most. The weekly review that takes three hours to prepare. The launch gate that requires six approvals via email. The pricing discussion that never quite resolves. Build an instrument for it. Run it once. It won't be perfect, but it will be better than what you have now.
Then expand. Share the instrument with your team. Let them modify it. Watch it improve. Soon you'll have five instruments, then ten, then a complete operating system running on interactive artifacts instead of static documents.
The companies that embrace this shift won't just be faster. They'll be playing a different game. They'll make decisions in minutes that take their competitors weeks. They'll have audit trails their competitors can't produce. They'll run experiments their competitors can't even imagine.
The tools are out there. The knowledge is here. The only barrier is inertia.
Copy these prompts. Paste them into ChatGPT or Claude. Customize them for your context. Run your next meeting inside an instrument. Capture the decision. Move forward.
The future of work isn't about AI replacing humans. It's about humans with instruments replacing humans with PowerPoint.
Build your first instrument today.
I make this Substack thanks to readers like you! Learn about all my Substack tiers here
Subscribed
