# Prompt Packs Are Dead. Long Live Skills > Source: > Published: 2026-05-30 19:17:33+00:00 Comment "REVOPS ROCKS" and I will DM you my 350 custom prompts. You have scrolled past it a hundred times. Join my list, get a billion prompts. Comment GROWTH for the swipe file. I revolutionized RevOps, join my Slack community to get the 350 prompts that prove it. The prompts are not the product. They are the bait. Somebody wants you on a list, and a fat number does the fishing. So you comment. The DM arrives. You open the PDF, and 350 prompts read like this: ``` Act as a RevOps leader and write a LinkedIn post about pipeline hygiene. Act as a RevOps leader and write a LinkedIn post about forecast accuracy. Act as a RevOps leader and write a LinkedIn post about lead routing. ``` Same prompt. Different noun. The author generated the whole file with AI in one sitting, using the same three formulas, so the number could carry the offer. "Custom" meant swapping the topic in a sentence. Pipeline. Forecast. Routing. Churn. Onboarding. That was not prompt engineering. That was prompt inflation. The 350-prompt swipe file is not a library. It is a mail merge with a lead-capture form bolted on. Here for the build, not the history? Skip to the actual Skill. But the history is not filler. How prompting got this brittle is the same story as how the new AI works behind the scenes. Read on and the design choices stop looking arbitrary. Good prompt writing came down to a few simple points. Everyone invented their own framework anyway. RTF, RACE, BFD, WTF. The real ones, roughly: Then APE, CARE, CLEAR, ICIO, and a fresh one every few weeks. Stack them and the trick shows. They rearrange the same nine ingredients like refrigerator magnets: Good ingredients, every one. The frameworks taught a real lesson, and they earned their moment. But they served one-shot prompting. Type it fresh, paste it from your swipe file, load it into a custom GPT or a Gemini Gem. However the prompt arrives, the shape holds: one input, one output, done. That world is closing. A million years ago, which is to say last year, a working prompt was worth its weight in gold. The good ones traveled hand to hand, screenshotted and hoarded. And the gold misfired anyway, fifteen to twenty percent of the time, the rate climbing with prompt complexity. The prompts worth keeping were the complex ones, so the prized prompts ended up failing the most. People poured weeks into the perfect prompt. ... until the instructions read like a ransom note. Every fix made the prompt longer, increasing the likelihood of missing any one of the expectations. AI starts ignoring instructions seemingly at random. The fixes meant to protect the important lines now buried them. Eventually it mostly worked. Then the next LLM model came out, reads the same words a little differently, and the prompt is now borken. The perfection never lived in the prompt. It lived in one version's quirks and expired on the next upgrade. A prompt was a key filed to fit a lock the vendor kept recutting. Three shifts carry the weight: Call them whatever this quarter's marketing calls them. The label keeps changing; the shift does not. The AI now carries far more of a task on its own. So the old question loses its grip. Old question: what prompt should I type? New question: what process should the AI follow? The team had a LinkedIn buyer-journey audit prompt. It scored a client's posts against a five-stage buyer-awareness framework, ran an intake interview, translated the framework into the client's business, gated on a confirmation step, then audited the posts. One rule stood out: a CSV of analytics alone does not cut it. The audit needs the post text. That prompt already beat its peers. It had sequence, gates, and the sense to stop and ask before classifying anything. It stayed a prompt, though. You could paste it from a doc for the next client, but you also had to hand-edit every line that named the last one, and nothing enforced the rules baked into it. Forget to restate the CSV rule in the edit and it vanished. The prompt remembered nothing. You did, or you did not. The framework it leaned on, the spine everything else hangs from: ``` Stage 1 Unaware Buyer does not know the problem exists. Stage 2 Problem-aware Buyer feels the pain, cannot name the cause. Stage 3 Solution-aware Buyer knows approaches exist, comparing methods. Stage 4 Provider-aware Buyer compares specific vendors and mechanisms. Stage 5 Ready Buyer wants to act, needs the last objection cleared. ``` A prompt can name those five stages in a sentence. A Skill must know what to do at each one, when reach is hiding zero pipeline, and what to refuse. That gap is the whole article. A prompt graduates to a Skill when it carries: The LinkedIn audit cleared every line. The job never meant generating ideas. It meant running a diagnostic. So I packaged it as `linkedin-buyer-journey-auditor` , a Skill any consultant can run against any client. The layout: ``` linkedin-buyer-journey-auditor/ ├── SKILL.md ├── references/ │ ├── framework.md # the five stages, fully defined │ ├── classification-rubric.md # intent tests, not format tests │ └── objection-library.md # proof, risk reversal, decision friction ├── assets/ │ ├── intake-schema.yaml # required inputs before any work │ ├── content-template.csv # the shape of the post export │ └── audit-output.md # the deliverable template └── scripts/ └── stage_breakdown.py # deterministic distribution math ``` None of it is exotic. All of it separates a prompt that works once from a workflow that works every time. The original prompt said "audit my LinkedIn content." The Skill audits anyone. That one word, `my` , baked an assumption into a prompt meant for reuse. The SKILL.md opens by killing it. ``` ## When to use Run this when a consultant, agency, or founder needs to audit ANY person's or company's LinkedIn content against the buyer journey. The operator is rarely the subject. Never assume the person invoking the Skill is the person being audited. ## When invoked Begin at intake unless the operator has already supplied interview answers AND post text. If both exist, skip to classification. If either is missing, collect it first. ``` That second block matters more than it looks. The throwaway prompt said "START NOW with Phase 1, Question 1." That belongs to one conversation. The Skill states the entry condition instead, so it picks up wherever the operator already is. A prompt asks for context and hopes. A Skill defines the inputs as a schema and refuses to proceed without them. ``` # assets/intake-schema.yaml required: client_name: string # who is being audited company: string offer: string # what they actually sell buyer: string # the ICP, by role and context sales_cycle_days: integer # shapes how much mid-funnel matters awareness_level: enum[low, mixed, high] # what the buyer already knows content_goal: enum[pipeline, authority, recruiting, fundraising] required_artifacts: post_text: required # the words, not just the numbers analytics_csv: optional # impressions/reactions if available refusal_rules: - if post_text missing: ask for it, do not classify from a CSV - if only analytics_csv present: explain numbers cannot reveal a buyer stage; a post about churn and a post about pricing can post identical impressions and serve opposite stages ``` Six fields and two refusal rules. The `sales_cycle_days` field is not decoration. A 14-day sale tolerates a thin middle. A nine-month enterprise sale dies in the middle, so the audit weights Stages 3 and 4 harder when the cycle runs long. The Skill reads the field and adjusts. A prompt would have shrugged. The five stages are generic. The buyer is not. Before the Skill touches a single post, it maps the abstract stages onto the client's real buying motion and asks the operator to confirm. For a fractional CRO selling to PE-backed SaaS founders, the map comes back like this: ``` Stage 1 "Revenue is fine, we just need more reps." Stage 2 "Hiring more reps did not fix it. Something upstream is broken." Stage 3 "Maybe the GTM motion itself needs an operator, not headcount." Stage 4 "A fractional CRO could do this. Is that better than a full-time hire?" Stage 5 "This person. Now. What does the engagement look like?" ``` Then the gate: ``` ## Confirmation gate Present the translated map. Ask: "Does this match how your buyer actually moves?" Do NOT classify any post until the operator confirms or corrects the map. A wrong map produces a confident, useless audit. ``` This gate is cheap to write and expensive to skip. Run the audit against a mismapped funnel and you get a polished report that misreads every post. The operator confirms in ten seconds. The Skill spends those ten seconds buying the rest of its own credibility. Most audits die here. People classify by what a post looks like. A hot take must be top-of-funnel. A framework must be mid-funnel. A case study must be bottom. The surface lies. The rubric classifies by what belief the post moves, not what shape it takes. ``` ## Classification rubric (references/classification-rubric.md) Ask of every post: which belief does this shift, for a buyer at which stage? Format is a hint, never the verdict. ``` Three worked examples, lifted from a real run. **Post A.** *"Most 'AI strategy' decks are last year's digital-transformation deck with find-and-replace."* Surface reads Stage 1. Contrarian, punchy, built for reach. Intent says Stage 2. It names a pain the buyer already feels, wasted strategy spend, without offering a fix. That does not move someone from unaware to aware. It moves them from "vaguely annoyed" to "I have a named problem." **Problem-aware.** **Post B.** *"The four-part framework we run before touching a single GTM tactic."* Surface reads Stage 3, and intent agrees. It teaches a method, carrying the buyer from "I have a problem" toward "problems like mine get solved this way." **Solution-aware.** Genuine middle-funnel. **Post C.** *"We cut a client's sales cycle 40% in one quarter. Before and after."* Surface reads Stage 5, the closing proof. Intent says Stage 4. It is comparison fuel for a buyer asking whether this provider delivers, not the final nudge for a buyer ready to start. The Stage 5 version would clear the last objection: how the engagement begins, what the risk reversal is, why now. This post does not. **Provider-aware.** Three posts, three formats, and the format predicted the stage exactly zero times out of three. That is why the rubric ships as a reference file and not a sentence. A popular post and a valuable post share a metric and almost nothing else. The Skill scores every post across axes that pull apart on purpose. ``` post_id | stage | impressions | engagement_rate | buyer_relevance | commercial_value --------+-------+-------------+-----------------+-----------------+----------------- A | 2 | 18,400 | 4.1% | high | medium B | 3 | 2,100 | 1.2% | high | high C | 4 | 3,800 | 2.0% | high | high D | 1 | 41,000 | 6.8% | low | none ``` Post D is the trap. Forty-one thousand impressions, the best engagement rate in the set, and zero commercial value because it reached the wrong crowd with the wrong belief. A metrics-only audit crowns Post D. The Skill flags it as reach without revenue and moves on. Engagement is a vanity axis. The Skill treats it as one. Now the deterministic part. `stage_breakdown.py` takes the classified posts and reports the distribution. No AI judgment, just arithmetic the AI should never eyeball. ``` python # scripts/stage_breakdown.py import csv, sys from collections import Counter def breakdown(rows): stages = Counter(int(r["stage"]) for r in rows) total = sum(stages.values()) for s in range(1, 6): pct = 100 * stages[s] / total if total else 0 bar = "█" * int(pct / 4) print(f"Stage {s}: {stages[s]:>3} ({pct:4.1f}%) {bar}") middle = sum(stages[s] for s in (2, 3, 4)) print(f"\nMiddle (2-4): {100*middle/total:.1f}% of content") if __name__ == "__main__": with open(sys.argv[1]) as f: breakdown(list(csv.DictReader(f))) ``` A typical founder's feed prints something brutal: ``` Stage 1: 22 (44.0%) ███████████ Stage 2: 6 (12.0%) ███ Stage 3: 3 ( 6.0%) █ Stage 4: 4 ( 8.0%) ██ Stage 5: 15 (30.0%) ███████ Middle (2-4): 26.0% of content ``` Forty-four percent reach plays at the top. Thirty percent "book a call" at the bottom. Twenty-six percent doing the work in the middle, where a long sales cycle actually closes. The audit stops saying "here is your content mix" and starts saying "your pipeline dies in the middle because you starved it." That sentence is the product. Weak advice names a stage. Strong advice names a belief the buyer has not yet adopted. The Skill carries a ladder that maps each stage to the belief it must install. ``` Stage 2 "I have a real, specific problem worth solving now." Stage 3 "There is a known way to solve this. Here is the method." Stage 4 "This provider's mechanism is the obvious path for me." Stage 5 "Acting now is safe. The risk of starting is low." ``` So instead of "create more Stage 3 content," the Skill writes: Your buyer feels the pain and reads your case studies, but nothing in the feed makes your method feel inevitable. Stage 3 is the gap. Write posts that show the mechanism working, step by step, so a skeptic concludes there is no other sensible way to do this. That recommendation a client can act on Monday. The stage label they cannot. Late-stage content lives or dies on proof and friction. The Skill ships a reference file so it never improvises the hard part. ``` ## objection-library.md proof_assets: named results, before/after, third-party validation risk_reversal: guarantees, pilots, staged commitments, exit ramps decision_friction: "who owns this internally", "what breaks if we wait", "what does week one actually look like" ``` When the audit reaches Stage 4 and 5 gaps, it pulls from this file instead of guessing what a nervous buyer needs to hear. The output ships as a fixed structure so two different operators produce comparable audits. ``` # audit-output.md 1. Client funnel map (confirmed) 2. Content distribution chart 3. The missing middle: where pipeline leaks 4. Top 5 posts by commercial value (not by reach) 5. Stage-by-stage gap diagnosis 6. 10 post recommendations, each tied to a belief shift 7. The one move that matters most this quarter ``` Section 7 is the discipline. It forces the audit to rank its own recommendations and stake one. A report with ten equal-weight suggestions is a report the client ignores. Before the operator sees a word, the Skill grades its own draft against a checklist. The role separation is the point. An agent that writes and grades in one move awards itself the grade, so the check runs as a distinct pass with its own rubric. ``` ## Self-review (run before output) - [ ] Did I classify by buyer intent, or did format decide? - [ ] Did I flag any high-reach, low-value post as the trap it is? - [ ] Did I quantify the cost of the biggest gap, not just name it? - [ ] Does every recommendation tie to a belief shift? - [ ] Did I rank one move above the rest? - [ ] Could the client act on this without asking me a question? Any unchecked box: revise, do not ship. ``` That loop separates a deliverable from a draft. A prompt has no idea whether its output is good. The Skill checks. A prompt says: Act as a B2B content strategist and audit my LinkedIn. A Skill says: Collect six intake fields and refuse to start without post text. Translate the five stages into this buyer's motion and confirm the map. Classify each post by intent, not format. Score buyer value apart from reach. Run the distribution math. Diagnose the missing middle in dollars. Tie every recommendation to a belief shift. Grade the work against a checklist. Then deliver a fixed template that stakes one move above the rest. The prompt makes a request. The Skill runs the work. The packs still hold something. They are ore. Buried in the slop sits the occasional framework, a recurring task, a clean output spec, a checklist someone actually thought about. Most of it dies as written. Some of it seeds a Skill. The play is to strip-mine the packs for the few durable parts and throw the rest back. Eight questions turn a prompt-shaped idea into a workflow-shaped system. The LinkedIn audit answered each one, which is how it earned the package. Answer those and you hold a Skill, not an incantation. Prompt mastery is not dead. It just got demoted. Clean phrasing still matters. Garbage in, garbage out survived the upgrade. But phrasing was always the small half of the job. The large half lives in workflow design: what to collect up front, when to refuse, how to grade the work before anyone else sees it. Nobody needs 350 prompts in a DM. They need ten workflows that know when to ask, when to wait, when to analyze, and when to ship. Prompt frameworks taught us the ingredients. Skills teach the kitchen how to cook.