Skills
Browse 278skills distilled from the world's best non-fiction.
Duplication Removal Via Extraction
Remove duplicated code across methods and classes by extracting small shared utilities first and letting larger structure (superclass, Template Method) emerge. Use whenever a developer says 'I'm changing the same code in multiple places', 'I'm fixing the same bug in 3 files', 'copy-pasted code everywhere', 'duplicate logic', 'DRY violation', 'same code in multiple classes', 'repeated patterns', 'shotgun surgery'. Activates for 'extract method', 'extract class', 'pull up method', 'Template Method pattern', 'superclass for duplication', 'deduplicate', 'shared utility', 'parallel classes'.
Library Seam Wrapper
Isolate third-party library dependencies behind thin wrapper interfaces to break vendor lock-in and enable testing. Use whenever a developer has direct calls to library classes scattered through production code and can't test or swap the library — 'library is killing me', 'vendor lock-in', 'can't mock this library', 'integration tests only for this SDK', 'AWS SDK everywhere', 'Stripe calls in 50 files', 'all API calls', 'wrapping a library', 'adapter for third-party'. Triggers for 'third party', 'SDK', 'library coupling', 'external service', 'API client'.
Monster Method Decomposition
Decompose a very large method (100+ lines, deeply nested) safely using automated refactoring and Feathers' Bulleted/Snarled classification. Use whenever a developer faces 'a huge method', 'I have a 500-line function', 'deeply nested conditionals', 'monster method', 'god method', 'need to break up this giant method', 'can't test this method it's too big', 'where do I even start with this method'. Activates for 'method extraction', 'IDE refactoring', 'automated extract method', 'introduce sensing variable', 'find sequences', 'skeletonize', 'coupling count', 'bulleted method', 'snarled method', 'break out method object'.
Scratch Refactoring For Code Understanding
Guide a developer through throwaway refactoring — restructure code freely without tests to understand it, then DISCARD. Use whenever a developer says 'I don't understand this code', 'this code is too complex to change safely', 'need to read legacy code', 'can't figure out what this does', 'overwhelmed by legacy', 'code archaeology', 'understand before change'. Also activates for 'scratch refactoring', 'throwaway refactoring', 'code comprehension', 'code reading technique', 'feature sketch', 'effect sketch', 'notes on legacy code'.
Tdd And Programming By Difference
Add features to tested code using TDD or Programming by Difference. Use whenever a developer is adding a feature to a class that already has tests (or can be brought under test) — 'how do I add this feature', 'test-driven development for legacy', 'red green refactor', 'TDD cycle', 'add behavior with tests', 'inheritance to add feature', 'programming by difference', 'subclass to add behavior', 'Liskov substitution', 'LSP violation'. Triggers for 'I just got this class under test, now I need to add X'.
Irresistible Offer Builder
Use this skill to construct a complete, irresistible offer using an 8-element checklist (Value, Language, Reason Why, Value Stack, Upsells, Payment Plan, Outrageous Guarantee, Scarcity). Triggers when a user wants to build an offer, design an irresistible offer, stop lazy discounting, fix a '10% off' offer, create a value stack, add an outrageous guarantee, design scarcity marketing, build a payment plan for a high-ticket product, improve offer conversion, write a compelling offer, design upsells, answer 'why-should-I-buy', or fill square #2 of the 1-Page Marketing Plan. Also activates for 'my offers aren't converting', 'I just discount to get clients', 'how do I make my offer stand out', 'I keep competing on price', or 'what should I include in my offer'.
Sales Conversion Trust System
Use when ready to convert nurtured leads into paying customers. Triggers on: "sales conversion", "close sales", "convert leads", "outrageous guarantee", "risk reversal", "3-tier pricing", "tiered pricing", "try before you buy", "free trial design", "trust signals", "testimonials", "customer objections", "fill square 6", "weak satisfaction guarantee", "pricing structure", "reduce sales friction", "everyone is in sales". Produces a sales-conversion.md document with a trust checklist, guarantee statement, 3-tier pricing menu, try-before-you-buy mechanic, and friction audit.
Customer Revenue Quality Audit
Classify every customer into one of four archetypes — Tribe, Churners, Vampires, or Snow Leopards — score your customer base using Net Promoter Score (NPS), and produce a segmentation report with a concrete fire/grow decision per customer. Use this skill when you want to run a customer audit, audit customer quality, segment customers, identify bad customers, identify draining customers, fire bad customers, clean up polluted revenue, distinguish Tribe from Churners from Vampires from Snow Leopards, classify customers by loyalty, assess NPS score, improve customer loyalty, remove toxic clients, free up team capacity, identify which customers to grow vs which to cut, run a customer quality review, calculate whether you have concentration risk from a single large customer, answer "should I fire this customer", identify your worst customers, stop subsidizing customers who cost more than they generate, or eliminate revenue that is actively making your business sick.
Conversation Format Selector
Choose the right conversation format — casual chat, scheduled meeting, or phone/video call — for a customer discovery interaction. Use this skill whenever the user is deciding between a formal meeting and a casual conversation, wondering how long customer interviews should be, unsure whether to meet in person or do a phone or video call, preparing to talk to potential customers at a conference or event or meetup, asking how to approach someone at a networking event or industry gathering, spending too much time scheduling formal meetings and not getting enough conversations done (the meeting anti-pattern), defaulting to hour-long Zoom calls for every customer interaction, planning the logistics or setting or duration of a customer conversation, or wondering whether a conversation should be structured or informal — even if they don't explicitly mention "format" or "meeting type." This skill is about HOW to have the conversation (format, duration, setting, formality level), not about finding people to talk to (use conversation-sourcing-planner) or what questions to ask (use conversation-question-designer).
Pessimistic Offline Lock Implementer
Use when offline-concurrency-strategy-selector (or your team) has chosen Pessimistic Offline Lock and you need to implement it correctly end-to-end. Handles: pessimistic locking, pessimistic offline lock, record locking, exclusive lock, lock manager design, lock timeout policy, acquire and release lock, stale lock cleanup, force release of abandoned locks, editing session lock, concurrent edit lock, edit lock implementation, record check-out pattern, lock table schema, durable lock storage (database-backed vs Redis vs in-memory), lock owner identity (user+session), coarse-grained lock at aggregate root (shared-version token vs root lock), implicit lock via base-class mapper / LockingMapper decorator / ORM interceptor / AOP aspect. Three-phase implementation: (1) choose lock type (exclusive-write vs exclusive-read vs read-write), (2) build durable lock manager (acquire/release/releaseAll/timeout), (3) define lock protocol (when to acquire, scope, release triggers, force-release, deadlock avoidance). Anti-pattern audit: SELECT FOR UPDATE across user think-time, in-memory lock table in clustered deployment, missing timeout policy, no owner identity, implicit-lock gaps, mixing optimistic with pessimistic carelessly. Produces a Pessimistic Offline Lock implementation plan covering lock type, storage choice, manager API, protocol spec, Coarse-Grained Lock integration, Implicit Lock wiring, UX spec (who holds lock + force-release), and test plan.
Legacy Code Change Algorithm
Guide safe modification of legacy code (untested production code) using Feathers' 5-step Legacy Code Change Algorithm. Use this skill whenever a developer needs to change code that lacks test coverage — adding a feature, fixing a bug, refactoring, or optimizing — and wants to avoid regressions. Activates for 'I need to change this code but there are no tests', 'how do I safely modify legacy code', 'inherited codebase', 'untested code', 'legacy system change', 'code without tests', 'refactor without regressions', 'make this code testable', 'cover and modify', 'don't break anything', 'risky change to old code', 'no test coverage', 'adding feature to old code', 'fixing bug in untested code', 'legacy codebase change safely'.
Advertising Media Roi Framework
Use when selecting advertising media channels, calculating Customer Acquisition Cost (CAC) per channel, deciding whether to stop, measure, or scale each channel, checking for dangerous single-point-of-failure lead source dependencies, or building a diversified media plan with per-channel tracking setup and ROI decision rules. Triggers: "advertising media", "ROI calculation", "CAC", "customer acquisition cost", "where to advertise", "marketing channels", "lead sources", "stop losing money on ads", "scale marketing", "single point of failure marketing", "diversify ad channels", "track marketing ROI", "media plan", "fill square 3", "which channels should I use", "is my advertising working".
Ackerman Bargaining Planner
Build a complete price-negotiation offer schedule using the Ackerman bargaining model. Use when someone asks "how do I negotiate a lower price?", "what should my opening offer be?", "how do I avoid splitting the difference?", "how do I structure my counter-offers so I don't give too much away?", or "how do I make my final offer feel credible?" Also use for: designing a salary negotiation offer sequence, structuring a vendor price reduction campaign, planning a real estate purchase offer ladder, deciding how far to push on a freelance rate, or building an offer schedule for any purchase or contract negotiation where you are trying to reach a specific target price. Produces a situation-specific ackerman-plan.md with your 4-stage offer sequence showing actual dollar amounts computed from your target price, scripted phrases for each stage, fairness-challenge responses, a noncash item list for the final offer, and anti-patterns to avoid. Works for any negotiation where you are the buyer (or the party making offers). Pair with calibrated-questions-planner (to generate questions to use between offers) and counterpart-style-profiler (to adapt delivery pace and tone).
Empathic Summary Planner
Build an active listening summary and emotional validation script before any negotiation, sales conversation, difficult conversation, conflict resolution, or persuasion attempt. Use this skill when you need to prepare a summary statement that triggers genuine agreement from a counterpart, create a listening script before a high-stakes conversation with an emotionally activated person, draft labels and paraphrasing language before a client call, build rapport with someone before making a request, prepare a stalled negotiation recovery plan using validation techniques, write an empathic opening before delivering difficult feedback, plan the listening sequence before a salary negotiation or sales discovery call, or generate a "that's right" trigger statement that signals real understanding — not just acknowledgment.
Commitment Verifier
Verify whether a counterpart's agreement is a real commitment or a polite escape. Use when someone asks "how do I know if they really mean yes?", "they agreed but I'm not sure they'll follow through", "my counterpart said yes but something feels off", "how do I tell if someone is stringing me along?", or "they said you're right — is that agreement?" Also use for: detecting when a verbal commitment won't survive contact with implementation, distinguishing genuine alignment from social pressure compliance, spotting deception signals in a counterpart's language or delivery, checking whether the decision-maker in the room actually has authority to commit, or preparing verification questions before a closing conversation. Analyzes an agreement interaction — conversation transcript, notes, or recalled exchange — and classifies each yes-type, flags verbal deception indicators, surfaces channel mismatches (words vs. tone vs. body language), and generates Rule of Three follow-up questions to confirm genuine commitment. Works for sales closes, contract negotiations, vendor agreements, hiring decisions, partnership deals, project sign-offs, and any high-stakes conversation where the difference between a real yes and a polite yes determines whether effort is wasted. Pair with calibrated-questions-planner (to design verification questions) and empathic-summary-planner (to build the rapport that makes genuine commitment possible).
Conversation Learning Process
Structure the before-and-after process around customer conversations so learning actually reaches the whole team. Use this skill when the user needs to prepare a team for a batch of customer conversations, set up pre-conversation learning goals, create a note-taking system for customer interviews, review and categorize conversation notes using signal symbols, run a post-conversation team review, share customer insights across the team, diagnose whether conversations are producing real learning or just going through the motions, fix a learning bottleneck where one person hoards all customer insights, their team keeps having conversations but nothing changes or plans never update, or a co-founder or teammate is out of the loop on customer feedback — even if they don't explicitly say "learning process" or "team review." Do NOT use for analyzing a specific transcript for data quality (use conversation-data-quality-analyzer) or evaluating whether a prospect gave a real commitment (use commitment-signal-evaluator).
Commitment Signal Evaluator
Evaluate whether a customer meeting produced real interest or just polite enthusiasm by classifying commitment signals into time, reputation, and money currencies. Use this skill after any customer conversation, product demo, sales call, or pitch where the user wants to know if the meeting actually advanced the deal, asks "was that a good meeting" or "how did it go" or "did that go well," says a meeting "went great" but nothing happened afterward, received enthusiastic feedback and wants to know if it is real, wonders whether someone is actually interested or just being polite, heard "I would definitely buy that" and wants to know if it means anything, wants to distinguish real leads from false-positive prospects (zombie leads), needs to score a pipeline of prospects for conversion likelihood, wants to detect polite rejections disguised as enthusiasm (compliment-stall pattern), or wants to identify early evangelists in their prospect pool — even if they don't explicitly mention "commitment signals" or "meeting evaluation." This skill evaluates meeting OUTCOMES and prospect INTEREST, not conversation data quality (use conversation-data-quality-analyzer) or conversation logistics (use conversation-format-selector).
Conversation Question Designer
Write, rewrite, or audit customer interview questions so they extract honest behavioral data instead of false validation. Use this skill whenever the user needs to prepare a conversation script for customer discovery, draft questions for an upcoming interview, fix questions that keep producing useless or vague answers, rewrite biased or leading questions into past-focused behavior-revealing ones, check whether their interview questions will trigger compliments instead of facts, or build a question list from learning goals — even if they don't mention "question design" or "The Mom Test." Do NOT use this skill to analyze conversation notes after a meeting (use conversation-data-quality-analyzer) or to decide which questions matter most strategically (use question-importance-prioritizer).
Question Importance Prioritizer
Prioritize which assumptions to validate first and produce focused learning goals before customer conversations — classifying risks as product risk versus market risk. Use this skill whenever the user has many assumptions or unknowns and needs to decide which to test first, wants to identify the 3 most important learning goals for their next conversation batch, needs to figure out what the riskiest parts of their business idea are, wants to separate must-validate assumptions from safe ones, is preparing strategic learning goals but not the specific interview questions, or suspects they are avoiding the scary questions that actually matter — even if they don't mention "prioritization" or "learning goals." Do NOT use this skill to write or rewrite the actual conversation questions (use conversation-question-designer) or to analyze notes from a completed conversation (use conversation-data-quality-analyzer).
Counterpart Style Profiler
Profile a negotiation counterpart's communication style and generate a tailored adaptation strategy. Use when asking "how should I approach this person?", "what communication style does my counterpart prefer?", "why is this negotiation not working?", "how do I adapt to this person's personality in negotiation?", or "what type of negotiator am I dealing with?" Also use for: diagnosing why previous conversations stalled or backfired; identifying whether warmth, data, or directness will land better; assessing self-type to avoid projecting your preferences onto the counterpart; preparing counterpart profiles for a negotiation one-sheet. Classifies counterparts into one of three communication archetypes (Analyst, Accommodator, Assertive) using observable behavioral signals, then produces a specific adaptation strategy covering communication tempo, information delivery, relationship style, and risk areas. Works from conversation history, emails, meeting notes, colleague descriptions, or any observable behavior data.
Unit Of Work Implementer
Implement Unit of Work (UoW) — the object that tracks new, dirty, clean, and removed entities during a business operation and commits all database changes together in the correct order. Use when asked: "how do I implement Unit of Work?", "how does Hibernate Session work under the hood?", "how do I avoid N+1 writes?", "how should I structure DbContext scoping?", "SQLAlchemy session management best practices", "EntityManager lifecycle", "ORM session management", "how to track entity changes in a Data Mapper layer?", "first-level cache", "identity map implementation", "object change tracking", "persistence coordination", "commit ordering with foreign keys", "how does EF Core SaveChanges work?", "dirty tracking", "how to batch database writes?", "UoW pattern implementation", "Hibernate Session vs EntityManager", "SQLAlchemy Session scope", "DbContext per-request", "entity state tracking". Applies when a Data Mapper pattern is in place (or being introduced) and the team needs disciplined change tracking, ordered commits, and first-level caching across a business operation. Integrates with Identity Map for cache and identity consistency. Integrates with Optimistic Offline Lock via version-conditioned UPDATE. Prerequisite: Data Mapper must be the chosen data-source pattern; UoW does not apply cleanly to Active Record (AR handles per-object persistence without a coordinator). If the data-source pattern has not been chosen, invoke `data-source-pattern-selector` first.
Target Market Selection Pvp Index
Use this skill to select the ideal target market or customer segment for a small business using the PVP Index (Personal fulfillment, Value to marketplace, Profitability). Triggers when a user asks to choose a target market, pick a niche, identify their ideal customer, score market segments, find the best customers to focus on, decide which customer type to target, narrow marketing focus, build a customer avatar, define an ideal customer profile, stop trying to serve everyone, or fill square #1 of the 1-Page Marketing Plan. Also activates for 'who should I market to', 'how do I choose a niche', 'which customers are most profitable', 'I serve too many segments', or similar market-selection questions.
Marketing Plan Canvas
Use this skill to build, assemble, or audit a complete 9-square 1-Page Marketing Plan canvas for any small or medium business. Triggers when a user asks to create a marketing plan, build a 1-page marketing plan, use the 1PMP framework, fill in the 9-square canvas, create a marketing strategy, get a complete marketing plan, start marketing a business, fix broken marketing, audit their marketing, or doesn't know where to start with marketing. Also triggers for: 'marketing plan', '1-page marketing plan', 'create marketing plan', 'marketing strategy', 'complete marketing plan', '1PMP canvas', '9 square canvas', 'marketing plan template', 'small business marketing plan', 'need a marketing plan', 'don't know where to start with marketing', 'my marketing is a mess', 'random acts of marketing', 'Allan Dib framework', 'before during after marketing', 'prospect lead customer framework', 'I have no marketing system', 'pull my marketing together', 'marketing audit'. This is the hub skill — invoke it whenever a user wants end-to-end marketing clarity, not just one tactical element.
Distribution Boundary Designer
Distribution design for enterprise systems: decide whether to distribute, where to draw the service boundary, and how to implement it with Remote Facade and Data Transfer Object (DTO). Use when deciding microservices vs monolith, evaluating process boundaries, extracting services, designing remote APIs, choosing coarse-grained API shape, preventing distribution-by-class anti-pattern, applying Fowler's First Law of Distributed Object Design, designing service extraction strategy, determining when distribution is warranted vs cargo-culting microservices, implementing Remote Facade pattern, designing DTOs independent from domain objects, choosing between gRPC vs REST vs message queue vs GraphQL for service boundary, monolith decomposition, service boundary design, remote API design, distribution strategy, when to distribute, process boundary decision, coarse-grained interface design.
Balanced Prospecting Cadence Designer
Design a balanced multi-channel prospecting cadence that prevents single-channel-obsession — the career-limiting habit of defaulting to the one channel you are most comfortable with while avoiding the channels that generate friction. Use this skill when someone asks about "prospecting cadence", "channel mix", "balanced prospecting", "multi-channel outreach", "how much phone vs email", "sales sequence design", "cadence template", "which channels should I use", "prospecting strategy", "should I be doing more phone calls", "how to balance in-person and remote outreach", "what percent of my prospecting should be social", "I'm better in person than on the phone", "am I too dependent on email", "how to structure my outreach across channels", "mix of prospecting methods", "single channel prospecting problem", or "how to diversify my prospecting approach". This skill gathers the user's product, sales cycle length, territory type, quota state, territory tenure, and current channel habits — then produces three artifacts: (1) a recommended channel-mix with explicit percentages (e.g., 40% phone / 25% email / 20% social / 10% in-person / 5% text) tuned to the user's specific situation, (2) a day-by-day weekly cadence template with time slots assigned to each channel, and (3) an anti-pattern audit that checks for single-channel-obsession and the "I'm so much better at X" rationalization. Based on Chapters 3 and 4 of Fanatical Prospecting by Jeb Blount.
Call Reluctance Diagnostic
Diagnose and coach through call reluctance, prospecting avoidance, and sales slumps. Use this skill when you can't make yourself prospect, are procrastinating on cold calls, avoiding the phone, or stuck in a low-activity week. Produces a diagnosis and 1-week intervention plan for: why can't I prospect, prospecting fear, three ps, perfectionism sales, paralysis from analysis, procrastinating on cold calls, slump mindset, mental toughness sales, prospecting motivation, can't pick up the phone.
Cold Email Writer
Write a complete cold prospecting email — subject line, body, and send-time recommendation — using Blount's AMMO planning framework and Hook-Relate-Bridge-Ask body structure from Fanatical Prospecting. Trigger this skill when you need to: - Write a cold email, prospecting email, or sales introduction email - Write an email to a prospect you have never contacted before - Improve an existing prospecting email that is not getting replies - Apply the AMMO framework (Audience / Method / Message / Outcome) to email planning - Build a Hook-Relate-Bridge-Ask email body that converts - Fix a subject line that is too long, uses a question mark, or is getting ignored - Check an email against the Three Cardinal Rules: Get Delivered / Get Opened / Get Converted - Improve email open rate, reply rate, or click-to-response conversion - Write a subject line under 50 characters with an action word, not a question - Understand what spam trigger words to avoid in a prospecting email - Run an email deliverability pre-check before sending - Write a post-trigger-event email to a prospect who just changed jobs, raised funding, or announced growth - Write a new-territory introduction email to a segment you have never contacted - Produce a complete send-ready email draft the user can send as-is or edit minimally - Apply the "AMMO email", "three cardinal rules email", or "Hook-Relate-Bridge-Ask" frameworks - Increase reply rate or reduce the number of cold emails going unanswered - Understand why "Hi [Name], I was browsing LinkedIn" emails get deleted immediately NOT for: building the core WIIFM bridge and because message nucleus that feeds this email (use prospecting-message-crafter first), or setting the email objective before writing (use prospecting-objective-setter). This skill produces a complete, send-ready email — not just the message component.
Gatekeeper Navigator
Navigate any gatekeeper situation — choose bypass vs befriend, apply the right technique, and draft scripts that pass the anti-manipulation check. Trigger this skill when you need to: - Get past a receptionist or administrative assistant who is blocking access to a decision maker - Reach a decision maker when you don't know their name, title, or direct contact information - Figure out whether to bypass a gatekeeper or build a relationship with them - Apply the sales-help-sales hack to reach a hard-to-reach prospect - Use the calling-other-extensions (go-around-back) technique to extract a DM name - Draft respectful, transparent scripts for working with gatekeepers on recurring accounts - Check a gatekeeper approach for manipulation, pretending, or bulldozing anti-patterns - Decide whether LinkedIn flanking, early/late calls, or in-person approaches fit your situation - Stop getting hung up on or added to a do-not-help list - Turn a hostile receptionist into a calendar ally over multiple visits NOT for: turning around a reflex response after you've already reached the prospect (use prospecting-rbo-turnaround), building the full 5-step phone call script once you're through (use cold-call-opener-builder), or crafting the bridge and because for the call itself (use prospecting-message-crafter). This skill handles the access layer — getting to the person who can say yes.
In Person Prospecting Route Planner
Plan a Hub-and-Spoke in-person prospecting route for a field sales day — mapping drop-by prospect visits around preset appointments to eliminate random driving and maximize face-to-face touches. Use this skill when planning in-person prospecting, field sales route, territory routing, door to door sales, drop-by visits, hub and spoke territory, T-call technique, cold in-person visit, outside sales route, in-person prospecting calls, field rep territory planning, IPP route, mapping prospects around appointments, drop-in sales calls, walking your territory, outside sales day planning, maximizing field time, face-to-face prospecting plan, or when a rep says "I'm just going to drive around my territory today" (which is exactly the anti-pattern this skill prevents). Takes a field rep's preset appointments, prospect list with addresses, and available driving time, then produces a Hub-and-Spoke 5-step territory routing plan, a per-stop action plan with opener scripts, and T-call technique instructions for opportunistic walk-ins.
Prospect List Tiering
Tier and prioritize a prospect list using the six-level Prospecting Pyramid framework — sorting every account from unknown contacts at the base to active buying-window prospects at the tip, then producing a daily action plan that specifies which tier to call first, what to do with each tier, and how to move prospects upward through the pyramid over time. Use this skill when the user has a raw prospect list and wants to know who to call first, asks how to prioritize their accounts, wants to rank or tier their CRM, wants to tier accounts, asks about the prospecting pyramid, needs an account prioritization framework, wants to identify which prospects are in the buying window, is building or cleaning up their CRM list, wants to stop randomly dialing and start with a system, wants qualified prospects separated from cold names, asks who should be top of their daily call list, has a mix of inbound leads and cold accounts and needs an order, wants to set up a conquest account list, or says their prospecting blocks feel unproductive and they need a better structure — even if they do not use the words "pyramid," "tiering," or "prioritization."
Prospecting Objection Handler
Classify prospect pushback and produce a scripted Anchor-Disrupt-Ask turnaround for any sales objection, reflex response, or brush-off using Blount's RBO Turnaround Framework. Trigger this skill when you hear or ask: - "objection handling" or "turn around a no" or "prospect said no" - "cold call objection" or "reflex response" or "brush off" - "not interested" or "happy with current" or "too busy" - "anchor disrupt ask" or "RBO turnaround" or "sales rejection" - "prospect pushed back" or "how do I respond to no" - "they said send me some information" or "call me later" - "they said they're happy with their current provider" - "turnaround script" or "handling a brush-off" or "dealing with rejection on a cold call" - "2-RBO rule" or "when to give up on a prospect" or "dead horse checkpoint" - "disrupt vs defeat" or "don't say I understand" or "never overcome objections" This skill classifies the pushback type (Reflex Response / Brush-Off / Objection), explains why each requires a different intervention, then produces a complete Anchor-Disrupt-Ask script for the specific pushback — including a fallback script for the second attempt and a dead-horse checkpoint for when to gracefully exit. NOT for: writing the initial cold call opener before pushback occurs (use cold-call-opener-builder), building the underlying bridge/because message (use prospecting-message-crafter), or planning a multi-touch email cadence.
Prospecting Objective Setter
Set the correct primary, secondary, and tertiary objective for any prospecting touch — before you make the call, send the email, or walk in the door. Use this skill when someone asks "what is my goal for this call", "should I try to set an appointment or just qualify", "appointment vs close — what should I go for", "what's my objective for this prospecting block", "should I qualify or pitch on this outreach", "what is the four objectives framework", "how do I decide what to ask for on a cold call", "primary secondary tertiary prospecting objective", "what should I optimize for in my cold email", "I have a new territory what should my prospecting objective be", "should I set appointments or close on the phone", "when is build familiarity the right objective", "my prospects are all unqualified what should I do first", or "how does sale complexity change my prospecting goal". Also invoke whenever a rep has a prospecting block coming up and wants to ensure every touch has a defined target outcome. This skill applies the Four Objectives framework (Set Appointment / Gather Information and Qualify / Close a Sale / Build Familiarity) to the rep's specific situation — sale complexity, channel, prospect qualification state, territory tenure, buying-window status — and produces a decision matrix mapping prospect tiers to correct primary/secondary/tertiary objectives. The output is an Objective Call Plan the rep uses to set up their next prospecting block.
Prospecting Ratio Manager
Calculate pipeline ratios and diagnose prospecting health using the Three Laws of Prospecting — use this skill when the user asks about pipeline ratios, close rate math, activity math, sales numbers, the 30-day rule, pipeline slump, feast or famine cycle, how many dials they should make, how much prospecting they need to do, whether they are prospecting enough, quota math, pipeline health, why their pipeline is empty, or why they are in a slump — even if they do not use those exact words. Produces a ratio dashboard (green/yellow/red status per law), a concrete daily activity target, and a fillable daily-tracker worksheet.
Prospecting Time Block Planner
Build a protected weekly prospecting calendar that separates Golden Hours (when buyers are buying) from Platinum Hours (before/after business hours for research and admin), calculates what each Golden Hour is worth in dollars, and installs a Power Hour protocol that eliminates distractions during focused dial blocks. Use this skill when someone asks "time management for sales", "when should I prospect", "golden hours", "power hour", "prospecting block", "calendar for sales", "how to protect prospecting time", "distractions killing my sales", "time equalizer", "platinum hours", "morning vs afternoon prospecting", "what time should I make cold calls", "how do I structure my sales day", "schedule for SDR", "how to stop email from killing my prospecting", "how to make more calls in less time", "why am I not hitting my dial targets", "how to concentrate my prospecting power", "hourly worth formula", or "sales time allocation framework". This skill gathers the rep's annual quota goal, working hours, current calendar constraints, and top distractors — then produces four artifacts: (1) hourly-worth calculation showing the dollar cost of every non-selling minute during prime time, (2) a Golden Hours and Platinum Hours weekly allocation tuned to the rep's territory and prospect time zones, (3) a 6-rule Power Hour protocol with a named distraction-elimination checklist, and (4) a ready-to-use weekly time-block calendar template. Based on Chapter 8 of Fanatical Prospecting by Jeb Blount.
Social Selling Touch Planner
Plan and execute a multi-touch social selling strategy that builds familiarity across LinkedIn, Twitter, and other social channels — layered on top of phone and email to increase open rates, response rates, and appointment conversion. Trigger this skill when you need to: - Build a social selling plan using the Law of Familiarity and the Five Levers framework - Design a LinkedIn prospecting cadence for a target account list - Create a multi-touch familiarity plan for cold, warm, or conquest prospects - Generate connection request templates and social touch messages that don't pitch - Warm up prospects before phone or email outreach to increase engagement - Understand how to use social touches as a layer alongside phone/email (not a replacement) - Set up a daily social selling time block that fits inside the prospecting schedule - Build a personal branding content calendar for social channels - Understand the Five Levers of Familiarity: Persistent Prospecting, Referrals, Networking, Brand, Personal Branding - Design a referral engine that systematically asks for introductions - Create a social cadence for 20-50 cold prospect touches, or 1-10 for warm prospects - Apply the Five Cs of social selling: Connecting, Content Creation, Content Curation, Conversion, Consistency - Identify which social channels to prioritize based on where prospects hang out - Build a Strategic Prospecting Campaign (SPC) for conquest accounts using social + outbound NOT for: writing a cold call script (use cold-call-opener-builder), building a multi-touch email cadence (use cold-email-writer), or diagnosing pipeline math (use prospecting-ratio-manager). This skill produces the social layer plan and templates; the actual message nucleus is built in prospecting-message-crafter.
Text Prospecting Sequence Builder
Build a situation-appropriate text prospecting sequence with timing, tone, and per-touch templates. Trigger this skill when you need to: - Text a prospect after a networking event or trade show meeting ("text message prospecting", "text after meeting") - Follow up on a hot inbound lead via SMS ("text a prospect", "SMS sales") - Rescue a no-show appointment with a text ("post-no-show text") - Send a text after leaving a voicemail ("text after voicemail", "post-vm text") - Know when it is and is not appropriate to text a prospect ("when to text a prospect") - Build a text sequence with correct timing and cadence ("text sequence", "mobile outreach") - Check whether a draft text message violates the 7 professional text rules - Understand the Bridge-Because pattern adapted for short-form text NOT for: writing a cold text to a complete stranger (text requires permission earned through prior contact — use cold-call-opener-builder or prospecting-message-crafter first). This skill assumes you have a legitimate reason to text: you met the person, they engaged with your content, or they came in as a warm inbound lead.
Customer Segment Slicer
Iteratively narrow broad customer segments into specific, findable sub-segments with who-where pairs. Use this skill whenever the user's target market is too broad, their customer definition is vague or generic ("small businesses," "students," "anyone who..."), they are getting mixed or inconsistent feedback from customer conversations that does not converge, they do not know who to talk to first, everyone seems like a potential customer, they need to decide which customer segment to pursue first, they are overwhelmed by too many potential customer types, they want to know who their ideal early customer is, they cannot figure out who to build for, they ask "who should I talk to" or "how do I narrow down my audience" — even if they don't explicitly say "segmentation" or "customer slicing." Do NOT use for finding or reaching customers (use conversation-sourcing-planner) or designing interview questions (use conversation-question-designer).
Cold Call Opener Builder
Build a complete, annotated cold call opener script using the Five-Step Telephone Prospecting Framework from Blount's Fanatical Prospecting. Trigger this skill when you hear or ask: - "cold call opener" or "phone script" or "what do I say when they pick up" - "telephone prospecting" or "sales phone call" or "cold calling script" - "five-step opener" or "phone opener" or "voice mail opener" - "prospecting call framework" or "how do I open a cold call" - "write me a call script" or "SDR call opener" or "BDR phone script" - "what do I say on a cold call" or "cold call introduction script" - "how to start a sales call" or "telephone prospecting framework" - "call opener template" or "sales call opening lines" - "how to not fumble the first 10 seconds" or "call structure for outbound" - "voicemail script" or "gatekeeper script" This skill produces a fully annotated, ready-to-use 5-line phone opener script in Name → Identify → Reason → Bridge → Ask order — plus a voicemail variant and a gatekeeper variant. It enforces no "How are you today?" pause, silence after the ask, and an explicit "because" in the bridge. Output is an annotated script, not abstract advice. NOT for: building the underlying bridge/because message (use prospecting-message-crafter first), setting the call objective (use prospecting-objective-setter), or handling objections after the opener (use prospecting-rbo-turnaround).
Prospecting Message Crafter
Craft or repair a prospecting message for any channel using the WIIFM → Bridge → Because → Ask framework from Blount's Fanatical Prospecting. Trigger this skill when you need to: - Write a cold call opener, cold email, LinkedIn message, or text prospecting message - Figure out "what should I say" to a prospect on any outbound channel - Build a bridge or reason ("because") that gives a prospect a compelling reason to meet - Diagnose why a current script or email is getting rejected and fix it - Answer "what's my value prop for this call?" or "how do I frame WIIFM?" - Check a draft for pitch vomit, cheesy openers, weak asks, or "I'd love to" language - Understand the difference between Targeted and Strategic bridge types and choose the right one - Write a Power Statement that answers "why should they choose me over the competition?" - Craft a message that leads with emotional value, insight/curiosity value, or tangible/logic value - Stop getting hit with "not interested" the second you open your mouth - Improve connect-to-conversation or email reply rates across any outbound channel NOT for: turning around an objection or brush-off after the opener (use prospecting-rbo-turnaround), building a full 5-step phone call script (use cold-call-opener-builder), or writing a multi-touch email cadence (use prospecting-email-writer). This skill produces the core message nucleus that all channel skills inherit — the bridge and because that make the prospect say yes.
Characterization Test Writing
Write tests that pin down the actual current behavior of untested legacy code as a safety net for change. Use whenever a developer needs to create a regression safety net before modifying code — 'I don't know what tests to write', 'what should I test in legacy code', 'how do I write tests for code I didn't write', 'tests to preserve behavior', 'golden tests', 'snapshot tests for old code', 'characterization test', 'cover before modify'. Activates for 'legacy code testing', 'untested code', 'write tests before changing', 'regression safety net', 'behavior-preservation tests', 'pin down behavior'.
Lead Capture Ethical Bribe Design
Use this skill to design a lead-capture ad strategy using an ethical bribe — a high-value free offer that self-selects high-probability prospects. Triggers when a user wants to capture leads, create a lead magnet, design a lead-generation ad, stop selling directly from ads, build a free report or free guide offer, set up gated content or a content upgrade, design a CRM capture plan, or fill square #4 of the 1-Page Marketing Plan. Also activates for 'ethical bribe', 'hunting vs farming', 'I keep running ads but nobody buys', 'how do I get people into my database', '3% buyer', 'addressable market', '1,233%', 'lead-gen not direct-sell', 'landing page offer', or 'capture leads from advertising'.
Referral System Design
Design an active referral system for a small business. Use this skill when you want to get more referrals, build a referral system, stop relying on word of mouth, ask for referrals without seeming desperate, write a referral script, create a gift card referral mechanism, apply the bystander effect override to referral asks, set upfront referral expectations with new customers, find joint venture referral partners, write a JV referral outreach email, profile complementary business partners for lead exchange, fill square 9 of the 1-Page Marketing Plan, apply the law of 250, design an orchestrated referral ask cadence, or turn customer satisfaction into a systematic lead source.
Customer Experience Systems Design
Design and document the four core business systems (Marketing, Sales, Fulfillment, Administration) and create memorable customer experiences through experience design and innovation. Use this skill when you want to systematize your business, build an operations manual, create checklists for recurring tasks, scale without being in the room, pass the fire-yourself test, remove yourself as the bottleneck, eliminate owner-dependency, design customer experience touchpoints, apply innovation to a boring or commodity business, differentiate by experience rather than product, run an E-Myth systems audit, identify the manager role missing from your business, document procedures so staff can run the business without you, build a business asset rather than buying yourself a job, or answer "what would happen if I left for six months?"
Change Effect Analysis
Trace the blast radius of a legacy code change and produce a test placement plan with pinch points. Use whenever a developer needs to decide WHERE to write tests for a pending change — 'what should I test?', 'where to test?', 'how far do the effects propagate?', 'what else could this break?', 'how to find test points', 'pinch point', 'effect sketch', 'impact analysis', 'blast radius', 'interception point', 'high-leverage test'. Triggers for 'I need to make many changes', 'many classes affected', 'cluster of related changes', 'cross-class refactoring'.
Negotiation One Sheet Generator
Build a complete Negotiation One Sheet — a five-section preparation document that covers your aspirational goal, a counterpart-validating situation summary, a preemptive accusation audit, a calibrated question bank, and a list of noncash offers — before any negotiation, sales conversation, contract discussion, salary negotiation, or difficult ask. Use when you need to prepare for a high-stakes conversation in a single document, when you want to stop improvising and start with a battle-tested preparation framework, when you keep leaving deals on the table by aiming at your bottom line instead of your aspirational target, when you need to combine emotional preparation with offer strategy into one coherent plan, or when you are coaching someone else through a complex negotiation. Also use before any negotiation where you have 20+ minutes to prepare and want to walk in with every major tool loaded: counterpart profile, labels, questions, offer sequence, and noncash options. Produces negotiation-one-sheet.md — a complete, ready-to-use preparation document with all five sections filled. Works standalone with simplified inline processes or in full-depth mode by invoking the seven supporting Level 0 skills. The hub of the Never Split the Difference skill set.
Enterprise Base Pattern Catalog
Reference catalog for Fowler's 11 enterprise base patterns from Chapter 18 of PEAA. Use when another skill or user says 'we need a Gateway here', 'this should be a Value Object', 'replace nulls with a Special Case', 'use a Service Stub for testing', or 'separate this interface from its implementation'. Covers all 11 base patterns: Gateway pattern (wrapping external systems), Mapper pattern (decoupling subsystems), Layer Supertype (shared base class per layer), Separated Interface (dependency inversion packaging), Registry (service locator), Value Object (value-identity immutable objects), Money pattern (monetary arithmetic, no floats, allocate-by-ratio), Special Case / Null Object (replace null checks), Plugin pattern (runtime-bound implementation), Service Stub (test double for external services), Record Set (generic tabular data structure). Identifies which pattern fits a described problem, provides canonical definition and modern language parallels, distinguishes Gateway (generic external-access wrapper) from Table Data Gateway (data-access pattern), flags Registry vs DI container tradeoff, and produces a short design note with implementation sketch. Also routes to the appropriate family selector when the problem is not a base pattern.
Accusation Audit Generator
Generate a preemptive objection audit and emotion-label bank before any high-stakes negotiation, difficult conversation, salary discussion, sales pitch, or conflict resolution. Use this skill when you need to defuse anticipated resistance before speaking, prepare labels for counterpart objections before a job offer negotiation, neutralize defensive reactions before presenting bad news, write preemptive acknowledgments before a pitch to a skeptical audience, prepare for a difficult performance review or client escalation, anticipate accusations before a contract renegotiation, build a delivery script for labeling counterpart frustrations, or create an accusation audit for a negotiation one-sheet.
Customer Discovery Process
Orchestrate the full customer discovery process — before, during, and after customer conversations — to systematically validate a business idea. This is the hub skill that sequences all other customer-discovery skills. Use this skill whenever the user wants to run customer discovery end-to-end, needs a step-by-step process for validating a product idea through customer conversations, wants to start customer discovery from scratch, wants to know what to do before and after customer meetings, needs a discovery status dashboard showing validation progress, suspects their discovery process is broken or unproductive, wants to diagnose whether they are just going through the motions, needs a customer development or lean validation framework, or asks "how do I validate my idea," "what's the full process for talking to customers," or "what should I do next in customer discovery" — even if they don't explicitly mention "discovery process." Do NOT use for writing specific interview questions (use conversation-question-designer), narrowing a customer segment (use customer-segment-slicer), or analyzing a single conversation transcript (use conversation-data-quality-analyzer).
Big Class Responsibility Extraction
Identify and extract responsibilities from an oversized class using Feathers' 7 heuristics + feature sketches. Use whenever a developer faces 'this class is too big', 'god class', 'monster class', '500-line class', 'class with 50+ methods', 'class with too many responsibilities', 'SRP violation', 'hard to test because class does too much', 'team keeps editing same class', 'merge conflicts on one class'. Activates for 'single responsibility', 'extract class', 'class decomposition', 'responsibility split', 'interface segregation', 'class bloat', 'swamp class', 'god object', 'feature sketch', 'class too big'.
Legacy Code Addition Techniques
Add new functionality to untested legacy code using Sprout Method, Sprout Class, Wrap Method, or Wrap Class — whichever best fits the dependency profile. Use whenever a developer needs to add a feature, log statement, validation, or any new behavior to legacy code that they can't easily test — 'I have to add this feature fast', 'no time for a big refactor', 'just need to log this', 'add a check to existing method', 'need to add behavior without breaking legacy', 'sprout method', 'sprout class', 'wrap method', 'wrap class', 'decorator for legacy'. Activates for 'quick change to legacy', 'under time pressure', 'can't test this class but need to add a feature', 'extend without editing'.
Black Swan Discovery
Identify the hidden unknowns that will determine whether your negotiation succeeds or fails before you ever make an offer. Use when someone asks "why is my counterpart acting irrationally?", "why does this deal keep stalling for no apparent reason?", "what am I missing about this negotiation?", "how do I find out what the other side really wants?", or "why won't they just say yes when the deal is clearly good for them?" Also use for: diagnosing a stalled sales cycle where the prospect keeps deflecting, investigating why a candidate rejected an offer that seemed strong, uncovering hidden constraints before entering a high-stakes contract renegotiation, mapping leverage before a complex partnership discussion, or rebuilding a broken negotiation relationship. Produces a black-swan-report.md with a hypothesis map of unknown unknowns in all three categories (worldview mismatches, hidden constraints, hidden agendas), a leverage inventory across all three leverage types, and a prioritized bank of investigation questions to surface what you do not yet know. Pair with counterpart-style-profiler (to refine worldview hypotheses by type) and calibrated-questions-planner (to convert investigation questions into a deployment-ready set).
Conversation Sourcing Planner
Create a plan for finding and reaching people to have customer discovery conversations with, including channel selection, outreach messages, and warm intro strategies. Use this skill whenever the user does not know how to find people to talk to, does not know anyone in their target market, needs to reach potential customers but has no connections, wants to write a cold outreach email or LinkedIn message for customer conversations, needs help with warm introductions or getting introduced to prospects, is struggling to get meetings or conversations with target customers, wants to build a conversation pipeline or outreach cadence, asks "where do I find people to interview" or "how do I get customer meetings," needs to figure out the best channels to reach a specific customer segment, wants to plan cold or warm outreach for customer interviews, or wants to leverage events or communities or online forums to find conversation targets — even if they don't explicitly say "sourcing" or "outreach." This skill is about FINDING and REACHING people, not about who your target customer is (use customer-segment-slicer) or whether meetings should be casual or formal (use conversation-format-selector).
Lead Nurture Sequence Design
Use this skill to design a complete lead nurture system for a small business. Triggers when a user wants to set up a nurture sequence, email sequence, drip campaign, CRM follow-up system, shock and awe package, marketing calendar, or lead nurturing automation. Also activates for 'fill square 5', 'square #5 of the 1-Page Marketing Plan', 'how do I follow up with leads', 'CRM setup', 'email marketing', 'repeat customers', 'Joe Girard', 'drip campaign', 'marketing calendar', 'event-triggered automations', 'the money is in the follow-up', 'shock and awe package', 'physical mail marketing', 'nurture leads', 'prospect database', or 'I captured leads but don't know what to do with them'.
Data Source Pattern Selector
Choose the right data access pattern — Table Data Gateway, Row Data Gateway, Active Record, or Data Mapper — for a persistence layer. Use when asked "should I use Active Record or Data Mapper?", "which ORM pattern fits my app?", "when does Hibernate-style mapping make sense vs. Rails ActiveRecord?", "how do I structure my database access layer?", "data mapper or active record for my domain model?", "Row Data Gateway vs Active Record", "Table Data Gateway vs Data Mapper", "Fowler data source patterns", "persistence layer design", "ORM pattern selection", "choose ORM pattern", "database access layer architecture", "Hibernate vs Rails persistence style". Applies when designing a new persistence layer or refactoring an existing one. Routes each domain-logic pattern (Table Module, Transaction Script, Domain Model) to its natural data-source counterpart. Identifies the Active Record / Data Mapper mismatch anti-pattern (AR when schema is not isomorphic with objects; DM when AR would suffice). Maps each pattern to modern framework idioms: Rails ActiveRecord → AR pattern; Hibernate / Spring Data JPA / EF Core → DM; Django ORM → AR-leaning; SQLAlchemy Core → TDG-style; SQLAlchemy ORM → DM; Laravel Eloquent → AR. Warns against business logic creeping into Gateway classes. Produces a pattern decision record with rationale, framework notes, and migration path. If the domain-logic pattern has not yet been chosen, invoke `domain-logic-pattern-selector` first.
Marketing Message And Usp Crafting
Use this skill to craft a differentiated Unique Selling Proposition (USP), write a Problem/Solution/Proof elevator pitch, and engineer headlines that activate the 5 core emotional buying motivators. Triggers when a user asks to write a USP, unique selling proposition, craft a marketing message, build an elevator pitch, differentiate from competitors, answer 'why buy from me', write headlines, write copywriting or marketing copy, fix positioning, escape me-too marketing, stop competing on price, apply emotional marketing, target fear/love/greed/guilt/ pride in copy, identify pain points for messaging, write sales copy, or fill square #2 of the 1-Page Marketing Plan canvas. Also activates for 'quality and great service as USP', 'we offer the best service', 'how do I stand out', 'nobody knows what makes us different', 'my ads are not working', or similar messaging and positioning questions.
Unit Test Quality Checker
Evaluate a test suite against rigorous unit-test criteria, classify test types, and choose between fake and mock objects. Use whenever a developer asks 'are these unit tests?', 'why is my test suite slow', 'should I use mocks or fakes', 'fake vs mock', 'what's wrong with my tests', 'my tests hit the database / network / filesystem', 'how do I speed up tests', 'unit vs integration', or when reviewing a codebase's test quality. Activates for 'unit test', 'fake object', 'mock object', 'test double', 'test speed', 'test isolation', 'xUnit', 'JUnit / NUnit / CppUnit', 'slow test suite', 'flaky tests', 'test pyramid'.
Dependency Breaking Technique Executor
Select and execute the right dependency-breaking technique from Michael Feathers' catalog of 24 named techniques (Part III of Working Effectively with Legacy Code) for a specific testability obstacle. Use when a class or method cannot be placed under test due to a hard-coded dependency, and you need concrete step-by-step mechanics for breaking it safely — without existing tests protecting you. Activates for 'can't test this class', 'constructor dependency', 'global variable blocking tests', 'static call in method', 'inject a fake', 'break dependency for testing', 'extract interface legacy', 'subclass and override', 'parameterize constructor', 'encapsulate global', 'dependency injection without framework', 'extract and override', 'how to fake this in test', 'legacy code testability refactoring'.
Conversation Data Quality Analyzer
Analyze customer conversation notes or transcripts after a meeting to classify every statement as fact, compliment, fluff, or idea — separating real signal from noise. Use this skill whenever the user wants to review interview notes, check whether a customer call produced reliable data, figure out if enthusiastic feedback was genuine interest or polite lies, identify bad data patterns in a transcript, audit whether a conversation that "went great" actually produced usable facts, or suspects they are collecting compliments instead of validated evidence — even if they don't mention "data quality" or "bad data." Do NOT use this skill to write or improve questions before a conversation (use conversation-question-designer) or to evaluate whether a meeting produced real commitment signals like time, reputation, or money (use commitment-signal-evaluator).
Marketing Metrics Dashboard
Build a marketing metrics dashboard tracking the 7 key numbers every small business must measure: Leads, Conversion Rate, Average Transaction Value (ATV), Break-Even Point, Gross Margin, Churn Rate, and Customer Lifetime Value (CLV) — plus Customer Acquisition Cost (CAC). Use this skill whenever the user wants to measure marketing performance, set up a KPI dashboard, track marketing ROI, fill in their key numbers, understand which metrics to watch, analyze leads and conversion, calculate CAC, compute CLV, identify profit improvement levers, run a marketing analytics review, understand small business metrics, build a marketing scorecard, or model what happens when they improve just 3 metrics by 10%. Demonstrates the compounding leverage insight: small improvements across multiple metrics multiply — not add — producing disproportionate profit gains. Also covers the CAC vs profit-per-sale decision rule for evaluating whether a marketing campaign is a winner or loser.
Commitment Escalation Architect
Design commitment escalation sequences and detect when consistency pressure is being used against you. Use this skill when planning onboarding sequences, activation flows, user engagement funnels, conversion funnels, habit formation programs, behavioral change campaigns, sales sequences, negotiation strategies, written commitment campaigns, foot-in-the-door campaigns, progressive commitment ladders, lowball tactics, escalation ladders, self-image engineering, inner choice cultivation, consistency-based persuasion, commitment amplification, or defending against manufactured consistency pressure and commitment traps.
Customer Lifetime Value Growth
Grow Customer Lifetime Value (CLV) using five proven levers — raise prices, upsell at point of purchase, move customers up an ascension ladder, increase purchase frequency through reminders and subscriptions, and win back lapsed customers with a reactivation campaign. Use this skill when you want to increase customer lifetime value, grow CLV, grow revenue from existing customers, cross-sell or upsell, raise prices without losing customers, build a subscription model, increase repeat purchases, add recurring revenue, implement an ascension ladder, reactivate customers, win back customers, fill square 8, increase purchase frequency, run a reactivation campaign, grow revenue without new customer acquisition, apply the 20/80 rule to your customer base, or design a return-visit voucher system.
Data Access Anti Pattern Auditor
Audit a persistence layer and schema for data access anti-patterns: N+1 query (SELECT N+1), ripple loading, lazy loading anti-pattern, ghost/proxy identity trap (missing Identity Map), Active Record anti-pattern on non-isomorphic schema, Active Record / Data Mapper mismatch, Serialized LOB overuse (queryable data stored in BLOB/JSONB/TEXT), meaningful primary key leakage, business logic in Gateway classes. Given a codebase and schema, produces a prioritized anti-pattern inventory with code location, evidence snippet, consequence, and remediation that cross-references pattern-selector skills. Use this for ORM performance audit, ORM anti-pattern detection, persistence anti-pattern inventory, database access anti-pattern review, persistence layer review, data access review, audit persistence layer.
Domain Logic Pattern Selector
Choose domain logic pattern for enterprise application subsystems: Transaction Script vs Domain Model vs Table Module, and decide Service Layer thickness. Use when organizing business logic, choosing between procedural service methods and rich domain models, selecting enterprise app architecture, routing domain logic to the right pattern, deciding anemic domain model vs rich domain model, applying Fowler's complexity-vs-effort curve, determining when to use Domain Model, when to use Transaction Script for simple CRUD, when Table Module fits .NET RecordSet environments, deciding Service Layer facade vs operation script vs controller-entity, avoiding transaction-script-sprawl, avoiding anemic-domain-model anti-pattern, preventing stored-procedure logic leakage, structuring enterprise app business logic, domain logic organization, choose domain pattern, enterprise app business logic design.
Offline Concurrency Strategy Selector
Use when designing concurrency control for long-running edits where a business transaction spans multiple system transactions — user opens a record, edits for minutes or hours, then saves. Selects between optimistic locking (version column, collision detection at commit) vs pessimistic locking (record check-out, conflict prevention at load time) and decides whether to add Coarse-Grained Lock (aggregate-root lock for multi-object edits) and Implicit Lock (framework-enforced locking to prevent gaps). Handles: lost update prevention, concurrent edit collision detection, offline lock strategy, long-running transaction concurrency, version column design, lock table design, lock timeout policy, aggregate lock, editing concurrency, lock type selection (exclusive-read vs exclusive-write vs read-write). Diagnoses mis-configurations: DB-level locks held across user think-time, implicit-lock gaps, optimistic/pessimistic mixing on overlapping data, timestamp-based versioning pitfalls.
Transaction Isolation Level Auditor
Use when auditing database transaction configuration for concurrency safety — checking isolation level settings, diagnosing lost update bugs, non-repeatable read vulnerabilities, phantom read risks, or ACID compliance gaps. Applies Fowler's Table 5.1 (the explicit isolation-level × anomaly matrix from Patterns of Enterprise Application Architecture Chapter 5) to map READ UNCOMMITTED / READ COMMITTED / REPEATABLE READ / SERIALIZABLE to permitted anomaly classes: dirty read, non-repeatable read (inconsistent read), phantom read, and lost update. Produces a structured isolation audit report covering: current isolation level, permitted anomalies, code locations with read-modify-write without optimistic check (lost update vulnerability), SELECT FOR UPDATE correctness, long-transaction risks, ACID compliance at system-transaction level, and ACID gaps at business-transaction level across multiple requests. Covers: transaction isolation, database concurrency, optimistic locking, pessimistic locking, version column, READ COMMITTED default risks, REPEATABLE READ upgrade decisions, SERIALIZABLE overhead, immutability as concurrency escape hatch, Spring @Transactional isolation settings, Hibernate session isolation, SQLAlchemy transaction config, EF Core transaction isolation, business transaction ACID, saga atomicity, offline lock isolation. Triggers: 'we have a lost update bug', 'two users editing the same record', 'is our isolation level correct', 'should we use SERIALIZABLE', 'transaction audit', 'ACID compliance review'.
Safe Legacy Editing Discipline
Apply 4 editing disciplines when modifying legacy code: Hyperaware Editing, Single-Goal Editing, Preserve Signatures, Lean on the Compiler. Use whenever a developer is about to edit untested code, refactor without a safety net, or is caught in avoidance anti-patterns (Edit-and-Pray, Minimization Freeze, Legacy Code Dilemma paralysis). Activates for 'how do I refactor safely', 'edit legacy code without breaking it', 'preserve behavior during refactor', 'lean on the compiler', 'preserve signatures', 'single-goal editing', 'make safe changes', 'edit and pray', 'cover and modify', 'careful editing', 'refactor without tests', 'break dependencies safely', 'avoid regressions in legacy code'.
Reciprocity Strategy Designer
Design reciprocity-based persuasion strategies and detect when reciprocity is being used against you. Use this skill when planning give and take strategies, creating lead magnets or free value offers, designing favor-first or value-first outreach, building gift-based marketing campaigns, crafting free samples or free trials, writing content marketing that creates obligation, designing negotiation openings, planning door-in-the-face or rejection-then-retreat sequences, structuring concession-based selling, responding to unsolicited gifts or favors before a pitch, evaluating whether a gift creates obligation, planning reciprocal concessions in negotiation, or defending against manipulation through uninvited debts.
Calibrated Questions Planner
Generate a bank of open-ended strategic questions (how/what questions) for a negotiation, sales conversation, difficult discussion, or conflict situation. Use when someone asks "what questions should I ask in my negotiation?", "how do I get more information without seeming pushy?", "how do I find out who else is involved in this decision?", "what should I ask to understand their constraints?", or "how do I stop the other side from stonewalling me?" Also use for: designing interview questions that reveal unstated priorities, discovering hidden stakeholders who could kill a deal, identifying deal-breaking issues before they surface, uncovering the real decision-making process behind a stated position, or preparing questions for any high-stakes conversation where you need the other party to think and talk. Produces a situation-specific question bank organized by category (value-revealing, behind-the-table stakeholder, deal-killing issue), with follow-up label templates and deployment sequencing. Works for sales calls, job negotiations, vendor negotiations, partnership discussions, client discovery, conflict resolution, and any scenario where understanding the counterpart's full picture is critical. Pair with accusation-audit-generator (to defuse objections before asking) and commitment-verifier (to verify answers reveal real commitment).
Test Harness Entry Diagnostics
Diagnose exactly why a class or method cannot be placed under test and route to the right dependency-breaking technique. Use whenever a developer says 'I can't instantiate this class in tests', 'the test harness won't compile', 'this class has too many constructor dependencies', 'the constructor connects to the database', 'can't test this private method', 'I need to sense what this method does', 'hidden singleton dependency'. Activates for 'test harness', 'class under test', 'constructor dependencies', 'irritating parameter', 'hidden dependency', 'construction blob', 'pass null', 'construction test', 'method not accessible', 'method side effects', 'can't get this class in a test harness', 'can't run this method in a test harness', 'singleton in constructor', 'include dependencies', 'onion parameter', 'aliased parameter'.
Persuasion Content Auditor
Audit, analyze, review, or score any persuasive content against the 6 principles of influence: reciprocity, commitment and consistency, social proof, liking, authority, and scarcity. Use when someone wants to improve their copy, check their persuasion strategy, evaluate a landing page, review a sales email, audit marketing materials, or find out which influence principles they're using or missing. Triggers on: audit my copy, review my email, is this persuasive, persuasion score, influence check, analyze my landing page, make this more persuasive, improve my conversion rate, CRO review, check my sales page, why isn't this converting, which principles am I using, what's missing from my pitch, evaluate my offer, marketing copy review, persuasion audit, influence framework review, content persuasion analysis. Input: any piece of persuasive content — sales email, landing page, marketing copy, pitch deck, product page, social ad, proposal. Output: scored audit report with per-principle ratings, evidence citations, and specific rewrite recommendations.
Learning Calibration Audit
Diagnose and correct false confidence in learning mastery using cognitive science research. Use when you feel confident about a topic but keep failing tests, want to audit your metacognition for illusions of knowing, are preparing for a high-stakes assessment and need to verify actual mastery, or suspect your study method is producing Dunning-Kruger overconfidence. Also use for: identifying which of 7 specific cognitive distortions — fluency illusion, hindsight bias, Dunning-Kruger overconfidence, curse of knowledge, false consensus, imagination inflation, social memory contamination — is inflating your self-assessment accuracy; distinguishing reliable mastery indicators (delayed recall, novel problem transfer, peer explanation) from unreliable ones (rereading fluency, immediate recall, familiarity warmth); selecting calibration instruments (self-quizzing, cumulative quizzing, peer instruction) matched to the specific distortions detected; designing a dynamic testing cycle (assess → identify gaps → target practice → retest) as an iterative calibration protocol; and producing a calibration report with a retest schedule. Applies across all learning contexts — exam preparation, professional skill development, corporate training, language learning, technical certification. Works on document sets such as study plans, quiz results, self-assessment notes, and course materials.
Class Responsibility Realignment
Redistribute methods and fields to the classes that own them, repair broken inheritance hierarchies, and extend unmodifiable library classes. Use when: a method uses another class's data far more than its own (Feature Envy — the method belongs in the other class); a single logical change forces edits across many files (Shotgun Surgery — scattered behavior needs consolidation); a class delegates half or more of its methods without adding value (Middle Man — remove the hollow layer or collapse it into inheritance); two classes share too much private knowledge about each other (Inappropriate Intimacy — separate the entangled pieces); a recurring group of fields travels together across class boundaries (Data Clumps — extract the group into its own class); a class has grown to serve two distinct responsibilities that change for different reasons (Extract Class — split it); a class that used to have a purpose has been refactored down to almost nothing (Inline Class — absorb it into its most active collaborator). For inheritance hierarchies: move common behavior upward (Pull Up Method, Pull Up Field) when subclasses duplicate it; push specialized behavior downward (Push Down Method, Push Down Field, Extract Subclass) when only some subclasses need it; create a shared abstraction over two similar but unrelated classes (Extract Superclass); extract a protocol-only contract (Extract Interface) when clients use only a subset of the class; merge a hierarchy that has converged (Collapse Hierarchy); move similar-but-not-identical subclass methods into a common template (Form Template Method); swap inheritance for delegation (Replace Inheritance with Delegation) when a subclass uses only part of the superclass interface or inherits inappropriate data; swap back (Replace Delegation with Inheritance) when the delegation covers the full interface and adds no control. For unmodifiable library classes: add one or two methods as foreign methods in the client class; add many methods via a local extension (subclass or wrapper). Decision rule for encapsulation balance: Hide Delegate to shield clients from internal structure; Remove Middle Man when the delegating layer has grown hollow. Decision rule for inheritance vs delegation: use Extract Subclass when variation is fixed at construction time and single-dimensional; use Extract Class (delegation) when variation is runtime-flexible or multi-dimensional — "if you want the class to vary in several different ways, you have to use delegation for all but one of them."
Code Smell Diagnosis
Scan a codebase or code fragment for the 22 named code smells from Fowler's refactoring catalog and produce a prioritized diagnosis report with the specific refactoring prescription for each smell. Use when: a developer wants to know what is wrong with existing code before touching it; a code review reveals structural problems but no clear fix; a class or method feels wrong but the exact smell is hard to name; a refactoring effort needs a starting point and a prioritized order of attack; a code author wants to justify a refactoring to a team by naming the specific smell and the prescribed remedy. Covers all 22 smells: Duplicated Code, Long Method, Large Class, Long Parameter List, Divergent Change, Shotgun Surgery, Feature Envy, Data Clumps, Primitive Obsession, Switch Statements, Parallel Inheritance Hierarchies, Lazy Class, Speculative Generality, Temporary Field, Message Chains, Middle Man, Inappropriate Intimacy, Alternative Classes with Different Interfaces, Incomplete Library Class, Data Class, Refused Bequest, Comments. Maps each smell to its Fowler-prescribed refactoring(s) including conditional branches (same class vs. sibling subclasses vs. unrelated classes for Duplicated Code; few cases vs. type code vs. null for Switch Statements; etc.).
Method Decomposition Refactoring
Decompose long, tangled methods into clean, composable units using the 9 composing-method refactorings from Fowler's catalog. Use when: a method has grown too long to understand at a glance; code contains a comment that explains what a block does (the comment is a signal to extract); a method cannot be changed without understanding all of its internals; local variables are so numerous that Extract Method keeps failing; a method is doing several conceptually distinct things that are collapsed into one body. The flagship technique is Extract Method — applied when the semantic distance between the method name and its body is too large; name the fragment after what it does, not how it does it. Companion techniques handle the obstacles: Replace Temp with Query eliminates the local variables that block extraction; Split Temporary Variable separates a temp that has been reused for two different things; Introduce Explaining Variable names a sub-expression when extraction is blocked by too many locals; Remove Assignments to Parameters prevents a parameter from being reassigned and muddying the intent; Inline Method collapses a method whose body is as clear as its name; Inline Temp removes a temp that obstructs another refactoring; Replace Method with Method Object converts a hopelessly entangled method into its own class so that Extract Method can be applied freely; Substitute Algorithm replaces an obscure implementation with a cleaner one once the method is small enough. Trigger: Long Method smell from code-smell-diagnosis, or any method where a comment is needed to understand a code block.
Growth Mindset And Deliberate Practice
Diagnose fixed vs growth mindset patterns and design a deliberate practice protocol for expertise development. Use when someone wants to develop expertise in a skill domain, is struggling to improve despite repeated practice, attributes their performance plateau to talent limits, praises or criticizes someone for being a "natural," says "I'm just not good at this," avoids challenges to protect their reputation, or asks how to get to 10000 hours effectively. Applies Dweck's 4-quadrant model (fixed/growth mindset × performance/learning goal orientation) to classify the learner's current stance, identifies fixed-mindset signals and attribution patterns, then designs a deliberate practice plan using Ericsson's 5 characteristics. Growth mindset is the prerequisite — without it, deliberate practice collapses into avoidance. Together they form a complete talent vs effort expertise-building pathway. Produces: mindset diagnostic report + deliberate practice plan with feedback loops, mental model targets, and practice structure.
Scarcity Framing Strategist
Design and evaluate scarcity framing for offers, products, and campaigns using psychological research on loss aversion and reactance — covering time limits, quantity limits, and defense against fake scarcity.
Object Relational Structural Mapping Guide
Object-relational mapping structural patterns guide. Use when designing or auditing how domain objects map to relational tables — identity fields, foreign key mapping, association table mapping for many-to-many relationships, dependent mapping for child objects with cascade delete, embedded value for value object mapping, and serialized LOB for JSON column or blob storage. Applies when choosing ORM associations (Hibernate, SQLAlchemy, EF Core, ActiveRecord, Django ORM), deciding between a join table and nested foreign keys, mapping address or money value objects as inline columns, or detecting serialized LOB overuse on queryable data. Covers the six PEAA structural patterns: Identity Field (surrogate key vs meaningful key), Foreign Key Mapping (single-valued reference), Association Table Mapping (many-to-many via join table), Dependent Mapping (child lifecycle owned by parent), Embedded Value (value object as columns), Serialized LOB (graph serialized to JSON/BLOB column).
Conditional Simplification Strategy
Select and apply the correct refactoring for complex or tangled conditional logic. Use when: a method has a complicated if-then-else that obscures why branching happens (not just what happens); a series of conditions all produce the same result; the same code fragment appears inside every branch; a boolean variable is being used as a control flag to track loop state; nested conditionals bury the normal execution path under special-case checks; a switch statement (or long if-else-if chain) branches on an object's type and new types are expected; a method's parameter controls which of several distinct operations runs; null checks are scattered throughout client code for the same object. Covers all 8 conditional refactorings from Fowler Chapter 9: Decompose Conditional, Consolidate Conditional Expression, Consolidate Duplicate Conditional Fragments, Remove Control Flag, Replace Nested Conditional with Guard Clauses, Replace Conditional with Polymorphism, Replace Parameter with Explicit Methods, Introduce Null Object. Also covers the supporting technique Introduce Assertion for making implicit state assumptions explicit. Includes the key semantic distinction between guard clauses (rare special cases that exit) and if-else (equal-weight alternatives), and Fowler's rejection of the single-exit-point rule as a reason to avoid early returns.
Type Code Refactoring Selector
Select and execute the correct refactoring path for type codes — enumerations, integer constants, or string tags that flag object variants (e.g., ENGINEER/SALESMAN/MANAGER as ints, blood group as 0/1/2/3, ORDER_STATUS as strings). Applies Fowler's three-way decision tree to pick between Replace Type Code with Class, Replace Type Code with Subclasses, and Replace Type Code with State/Strategy, then drives the full mechanics for the chosen path through to Replace Conditional with Polymorphism. Use when: a class stores an integer or enum constant that controls conditional behavior in switch statements or if-else chains scattered across multiple methods or callers; Primitive Obsession or Switch Statements smells have been diagnosed and the root cause is a type code; a new variant keeps requiring edits in multiple places (classic signal that polymorphism is needed); a type code is passed between classes as a raw integer, weakening type safety and allowing invalid values; subclasses exist that vary only in constant return values (reverse path: Replace Subclass with Fields). Also covers the exceptions: use Replace Parameter with Explicit Methods instead of polymorphism when the switch affects only a single method and variants are stable; use Introduce Null Object when one of the cases is null.
Premium Pricing Strategy
Use when a business is pricing by copying competitors, losing deals on price, or struggling to grow margins — to diagnose commoditization, justify a premium price point with ROI evidence, and calculate the niche-specific multiplier that unlocks value-driven purchasing.
Social Proof Optimizer
Optimize social proof strategy using uncertainty and similarity conditions. Use this skill when designing testimonials, reviews, user counts, case studies, social validation signals, trust badges, FOMO messaging, herd behavior cues, peer influence copy, bystander effect awareness, landing page trust signals, customer stories, social media proof, community size claims, star ratings, product popularity indicators, referral social proof, expert endorsements, or any persuasion element that relies on others' behavior to guide decisions. Also use when auditing social proof for manufactured or fake signals, evaluating whether current testimonials are credible, detecting pluralistic ignorance in a group context, or designing a defense against manipulated social evidence.
Build Refactoring Test Suite
Build a sufficient automated test suite before refactoring existing code by applying a 6-step sequential construction workflow (test class → fixture → normal behavior → boundary conditions → expected errors → green-suite gate) and a bug-fix variant (write failing test first → reproduce → fix → verify green). Use this skill when you are about to refactor a class or module that lacks tests, when a bug report arrives and you need to pin it down before fixing it, when you want to establish the compile-and-test gate that makes every subsequent refactoring step safe to revert, or when you need to assess whether an existing test suite is adequate to protect a planned refactoring.
Data Organization Refactoring
Apply the correct data organization refactoring when code smells in data structure design are diagnosed — Primitive Obsession, Data Clumps, Data Class, or raw structural anti-patterns like magic numbers, positional arrays, and naked public fields. Covers the full Chapter 8 catalog: Replace Data Value with Object (primitive → first-class object); Change Value to Reference / Change Reference to Value (value vs. reference object decision); Self Encapsulate Field (internal field access via accessors); Encapsulate Field (public → private with accessors); Encapsulate Collection (raw collection → controlled add/remove protocol); Replace Array with Object (positional array → named-field object); Replace Magic Number with Symbolic Constant; Replace Record with Data Class (legacy record → typed wrapper); Duplicate Observed Data (domain data trapped in GUI → domain class + observer sync); Change Unidirectional Association to Bidirectional (one-way link → two-way when both ends need navigation); Change Bidirectional Association to Unidirectional (drop unnecessary back pointer). Use when: a field stores a raw primitive (string, int) but has behavior waiting to happen (formatting, validation, comparison); the same 2-4 data items travel together through method signatures and field lists (Data Clumps); a class exists only as a getter/setter bag with no behavior (Data Class); a collection field is exposed so callers can mutate it directly; positional arrays or records need to cross the boundary into object-oriented design; a numeric literal with special meaning appears in more than one place; a GUI class owns domain data that business methods need; a one-way association is insufficient or a two-way association has become unnecessarily complex. Type code refactorings (Replace Type Code with Class/Subclasses/State-Strategy) are handled by the sibling skill `type-code-refactoring-selector`.
Argument Organization Reviser
Revise the structural organization of a research paper draft by applying a four-level top-down procedure — Frame (intro/conclusion alignment), Argument (section reasons + evidence ratios), Paper Organization (key-term threading + section signals), and Paragraphs (topic sentence placement + length). Use this skill whenever the user has a complete draft and asks to revise, reorganize, or strengthen its structure — not its prose style. Triggers include: user shares a draft paper and asks for structural feedback; user says sections feel disconnected or the argument is hard to follow; user's introduction and conclusion seem to contradict or not reinforce each other; user suspects their sections lack clear points or bury them in the middle; user cannot tell whether their evidence-to-reasoning ratio is balanced; user's paragraphs open with evidence rather than claims; user is preparing to submit and wants a final organizational pass. Also triggers on: "revise my structure," "does my argument hold together," "my advisor said the organization is unclear," "do my sections flow," "I need to check the coherence." This skill applies structural revision only — it does NOT revise prose style or sentence clarity (use prose-clarity-reviser for that), and does NOT rebuild an argument from scratch (use research-argument-builder for that).
Counterargument Handler
Anticipate, acknowledge, and respond to reader objections and alternative views in a research argument. Use this skill when the user has a draft argument or storyboard and needs to identify which objections readers will predictably raise, wants to decide which objections to acknowledge and which to set aside, needs vocabulary and sentence templates for introducing and responding to counterarguments without weakening their position, has discovered a flaw in their argument and does not know how to handle it honestly, is building a cause-and-effect argument and needs to address competing causes, has made claims with counterexamples that readers will invoke, uses key terms that readers may define differently and needs to address definitional scope, or wants to avoid either ignoring objections (seeming ignorant) or acknowledging too many (losing argumentative focus). This skill is the detailed companion to research-argument-builder — use it after assembling the argument's core structure (claim, reasons, evidence) and before drafting, to map every acknowledgment slot with a calibrated response strategy.
Data Visualization Selector
Select the correct graphic type (table, bar chart, line graph) for a dataset and rhetorical goal, then design and frame it to communicate evidence clearly and honestly. Use this skill whenever the user needs to present quantitative data in a research paper, report, thesis, presentation, or professional document and asks: which chart should I use, how should I visualize this data, how do I make this graphic clearer, is my chart misleading, how do I label or title a table or figure, or how do I introduce a graphic in text. Also triggers on: "my advisor said the table is confusing," "should I use a bar chart or line graph," "how do I make readers see my point in this figure," "is this graph ethical," "my chart looks amateurish," "the scale on my graph looks off," or any request to improve the visual communication of numerical evidence. Covers the full workflow: verbal-vs-visual decision → graphic type selection based on rhetorical effect → design simplification → framing with title, intro sentence, and labels → ethical integrity checks.
Prose Clarity Reviser
Revise dense, unclear prose into clear, readable sentences by applying four diagnostic principles — characters-as-subjects, actions-as-verbs, old-before-new information flow, and complexity-last sentence endings. Use this skill whenever the user shares a draft passage, paragraph, or document and asks you to make it clearer, more readable, easier to follow, less dense, less academic-sounding, or better written — even if they don't use those words. Also triggers on: "can you revise this," "this feels clunky," "my advisor said this is unclear," "make this flow better," "my writing sounds stilted," or any request to improve prose style in research papers, reports, essays, grant proposals, or professional documents. Apply all four principles end-to-end; return a revised version with brief annotations showing what changed and why.
Research Argument Builder
Build a complete, structured research argument from a framed problem — assembling all five elements (claim, reasons, evidence, acknowledgment/response, warrant) using the Claim→Reason→Evidence chain. Use this skill when the user has a research problem or framed question and needs to construct the supporting argument that justifies their answer, has a working thesis or claim but does not know how to assemble the reasons and evidence that make it hold, needs to identify which of the five claim types (fact, definition, cause, evaluation, policy) their main claim is and what kind of evidence each type demands, wants to evaluate whether their claim is specific and significant enough to anchor an argument, cannot tell whether a statement is a reason or evidence and keeps treating soft generalizations as hard data, has evidence but cannot determine whether it meets the quality standards (accurate, precise, sufficient, representative, authoritative) their readers will apply, needs to plan their argument visually using a storyboard (claim + reasons + evidence cards) before drafting, or wants to thicken a thin argument by identifying where acknowledgments and warrants are needed. This is the hub skill for research argumentation — use it before counterargument-handler (which handles detailed acknowledgment/response), warrant-tester (which tests whether reasons are genuinely relevant to claims), and research-paper-planner (which turns the completed argument structure into a paper outline).
Research Introduction Architect
Draft a complete research introduction and matching conclusion using the Context→Problem→Response architecture. Use this skill when the user has a framed research problem (condition + consequence) and needs to write or revise the opening and closing sections of a research paper; when an introduction exists but reads as a flat topic announcement instead of a problem-driven argument; when the user cannot decide whether to state the main point in the introduction (point-first) or withhold it for the conclusion (point-last) and needs to understand the trade-offs; when the first sentence of the introduction is a dictionary definition, a grand universal claim ("Throughout history…"), or a repetition of the assignment prompt; when the conclusion merely restates the introduction without adding new significance or calling for further research; when the user needs guidance on how much context to provide — neither too sketchy nor encyclopedic — based on the audience's prior knowledge; when the pacing of an introduction (fast vs. slow context setup) needs to match audience expertise level; or when the user wants a checked draft that correctly omits the context element (problem well-known) or consequence element (widely understood) rather than including them by default. This skill outputs a draft introduction and conclusion. It does NOT frame the research problem from scratch — use research-problem-framer for that.
Research Paper Planner
Build a storyboard-based plan for a research paper and turn it into a first draft. Use this skill when the user has assembled a research argument — a main claim with supporting reasons, evidence, and acknowledgments — and now needs to organize it into a coherent, reader-ready structure before writing. Triggers include: user has a thesis and evidence but does not know how to order the sections; user suspects their draft is organized as a research narrative (what they found first) rather than as an argument (what readers need); user's draft summary-hops across sources without asserting their own claim (patchwork writing); user wants a working introduction sketch to start drafting; user is staring at a blank page and cannot begin; user needs to decide where to state their main point — end of introduction or end of paper; user wants to know whether to order reasons by importance, complexity, familiarity, or contestability. This skill does NOT build the underlying argument from scratch — use research-argument-builder for claim, reason, evidence, acknowledgment, and warrant assembly before using this skill.
Research Problem Framer
Transform a research question into a fully framed research problem that readers recognize as worth solving, using the condition+consequence structure and the So What? cascade test. Use this skill when the user has a research question but cannot explain why readers should care about the answer, has completed the 3-step significance formula but the Step 3 consequence still feels abstract or weak, is writing an introduction and the reader's "So what?" objection keeps coming back, cannot tell whether their project is pure or applied research and whether that matters for their introduction, wants to verify that solving their conceptual problem actually serves a practical one, has a research question that feels personally interesting but lacks community relevance, is being asked by an advisor or reviewer "why does this matter?", needs to state a research problem in formal proposal or introduction language, wants to understand the difference between a research question (condition) and a research problem (condition + consequence) and why the problem frame is what goes in the introduction, or is building a research argument but keeps getting feedback that readers don't feel the stakes. This skill handles problem framing and consequence articulation; it does NOT formulate the initial research question (use research-question-formulator for that) or write the claim/thesis statement.
Research Question Formulator
Transform a broad topic into a focused, answerable research question with built-in significance using the 3-step sentence-completion formula (topic → direct question → So What?). Use this skill when the user has a subject or area of interest but no specific question, has a vague topic like "climate change" or "leadership" and needs to narrow it to something researchable, says they don't know what their paper is really about, is collecting too many notes without a clear direction, wants to know if their research question is worth asking, needs to test whether their topic is too broad (4-5 words = too broad), has a yes/no question that won't drive analysis, is asking a settled-fact question that doesn't open inquiry, wants to move from aimless reading to targeted evidence gathering, has a draft thesis but lost track of what question it answers, or is stuck at the beginning of a research project and doesn't know where to start — even if they never use the phrase "research question formulation." This skill handles question generation and significance testing; it does NOT write the thesis statement (use a separate skill) or plan the full argument structure.
Source Evaluator
Evaluate, triage, and actively read a set of research sources — books, articles, and online materials — by applying a dual-axis relevance-and-reliability screen, source-type skim protocols, and a two-pass active reading method that extracts data, arguments to respond to, and generative agreements and disagreements. Use this skill when you have a candidate source list and need to cut it to a workable set, when you need to verify that a source is credible before citing it, when you are reading sources to find a research problem or refine a hypothesis, when you need to take notes that accurately capture what a source argues without misrepresenting it, or when you must identify where sources agree and disagree so you can position your own argument within a field's conversation.
Source Incorporator
Incorporate quoted, paraphrased, and summarized sources into research writing by applying a 3-branch selection decision tree, 3 integration methods for quotations, and a 5-mechanism inadvertent plagiarism prevention checklist. Use this skill when drafting or revising a paper that uses sources and you need to decide whether to quote, paraphrase, or summarize a passage; when you need to weave quotations into your prose grammatically and meaningfully; when you need to make explicit to readers why evidence is relevant; when you must choose a citation style; or when you want to audit a draft for the five most common forms of inadvertent plagiarism before submitting.
Warrant Tester
Test the warrants in a research argument — the general principles that connect reasons to claims. Use this skill when a reader might accept a reason as true but still deny it is relevant to the claim, the argument contains a logical leap between a reason and a claim that no stated principle explains, the user needs to decide whether to state a warrant explicitly or leave it implicit, the argument needs to identify which type of warrant is being used (experience-based, authority-based, system/definitional, cultural, methodological) so it can be challenged or defended appropriately, the user is writing for an audience outside their field who will ask "but why does that reason matter to your claim?", a warrant appears to be too broad and needs qualification before it can survive challenge, competing warrants exist and the argument must show why its warrant should prevail, or the user suspects their argument is flawed but cannot identify where — surfacing the implicit warrant often reveals the problem. This skill depends on research-argument-builder (which assembles the full argument structure) and is typically used after reasons and claims have been identified but before final drafting.
Refactoring Readiness Assessment
Assess whether a codebase situation warrants refactoring and determine the right approach before any structural changes begin. Use this skill when a developer is about to modify existing code and needs to decide: should I refactor first, refactor not at all, or rewrite entirely? Triggers include: developer is adding a feature and the existing code is hard to understand or extend; developer just received a bug report and suspects the code structure is hiding more bugs; a code review has surfaced design concerns and the team wants concrete guidance; code appears to have been copied more than twice in similar form; developer is unsure whether to clean up code before a deadline; codebase uses a published interface or is tightly coupled to a database schema and the developer wants to know the constraints before restructuring; developer suspects the code is so broken it cannot be stabilized without a full rewrite. This skill produces a structured go/no-go assessment and session plan — it does not apply any refactoring itself. Use code-smell-diagnosis after this skill to identify specific smells, then individual refactoring skills to apply transformations.
Desirable Difficulty Classifier
Classify any learning activity, practice structure, or instructional design element as a desirable difficulty (strengthens encoding) or undesirable difficulty (creates friction without learning benefit). Use this skill when an instructional designer, trainer, teacher, or learner wants to audit a course design, training session, study method, or practice regimen for evidence-based difficulty management — even if they don't use the phrase "desirable difficulty." Applies to onboarding programs, corporate training, academic course design, self-study plans, coaching sessions, and skill development programs. Identifies which of six proven difficulty strategies are present or absent (spacing, interleaving, variation, retrieval, generation, elaboration) and generates specific redesign recommendations. Do NOT use this skill to build a full study schedule (use retrieval-practice-study-system), to assess learner readiness or aptitude, or to evaluate content quality unrelated to difficulty structure.
Evidence Based Classroom Designer
Design or redesign any course, class, or training session using evidence-based instructional principles. Use this skill when a teacher, instructor, or instructional designer wants to improve student retention and achievement through classroom design, course design, quiz design, or active learning strategies — even if they don't mention "retrieval practice" or "spaced repetition." Triggers include: instructor wants to reduce failure rates in a gateway course; teacher finds students forget material within days of a lecture; instructor relies on midterm and final exams as the only assessment; teacher wants to move from passive lecturing to active learning without losing content coverage; instructor wants to close the achievement gap between well-prepared and under-prepared students; course designer wants to embed low-stakes quizzing into a curriculum; teacher wants to raise student performance on Bloom's higher-order thinking levels; instructor wants to redesign student engagement without adding complexity. Works for K-12 teachers, university professors, corporate trainers, and instructional designers. Do NOT use this skill to build a personal study system for a single learner (use retrieval-practice-study-system), to create a practice schedule alone (use practice-schedule-designer), or to audit a single learning activity for difficulty structure (use desirable-difficulty-classifier).
Enterprise Architecture Pattern Stack Selector
Select the right enterprise application architecture patterns for every layer of your system using Fowler's PEAA decision framework. Use this skill when designing or refactoring an enterprise app and asking: which domain-logic pattern should I use (Transaction Script, Domain Model, Table Module)? Which persistence pattern fits my stack (Active Record, Data Mapper, Table Data Gateway, Row Data Gateway)? Which web-presentation pattern applies (Front Controller, Page Controller, Template View)? How do I combine these into a coherent full-stack architecture? Triggers include: 'help me choose architecture patterns', 'which Fowler pattern for my app', 'enterprise application architecture', 'PEAA pattern selection', 'layer pattern selection', 'domain logic pattern vs persistence pattern', 'refactor enterprise app to patterns', 'how to structure a Spring/Django/Rails/ASP.NET app', 'what persistence pattern should I use', 'enterprise architecture decision', 'full-stack pattern stack', 'patterns of enterprise application architecture'. This is the hub skill — it maps your subsystem context to per-layer family selector skills and produces a consolidated Pattern Stack Decision Record.
Session State Location Selector
Route session state storage to the right location — Client Session State (cookies, JWT, hidden fields, URL parameters), Server Session State (in-memory or Redis session store), or Database Session State (SQL/NoSQL session table) — based on six dimensions: bandwidth cost, security sensitivity, clustering and failover needs, responsiveness, cancellation requirements, and development effort. Use when designing session management for a new web application, debugging sticky-session or node-pinning scaling problems, deciding between JWT vs server session vs database session, choosing a shared session store for a clustered or elastic deployment, handling shopping carts, multi-step forms, auth context, or edit-in-progress across HTTP requests, or auditing for session bloat or unsigned client session state. Applies to stateless session design, distributed session architecture, and HTTP session management in any language or framework. Relevant keywords: session state, session storage, session location, sticky sessions, JWT vs session, shared session store, stateless session, session management, HTTP session, distributed session, session cookie, server session, database session, Redis session, node-pinning, session scaling, client-side session, server-side session, session bloat.
Big Refactoring Planner
Plan and execute architectural-scale refactoring campaigns that take weeks to months — the four named patterns for large-scale structural restructuring from Fowler and Beck's Chapter 12. Use when: an inheritance hierarchy is doing two distinct jobs and subclass names share the same adjective prefix at every level (Tease Apart Inheritance); a codebase written in an object-oriented language uses a procedural style with long methods on behavior-less classes and dumb data objects (Convert Procedural Design to Objects); GUI or window classes contain SQL queries, business rules, or pricing logic instead of just display code (Separate Domain from Presentation); a single class has accumulated so many conditional statements that every new case requires editing the same class in multiple places (Extract Hierarchy). Applies when code-smell-diagnosis has surfaced Parallel Inheritance Hierarchies, Data Class, or Large Class with deep conditional branching and the fix is too large for a single refactoring session. Distinguishes between the four patterns by structural signal, selects the correct pattern and variant, and produces a multi-week campaign plan with interleaved feature development milestones.
Value Equation Offer Audit
Audit and score an existing offer or service using the four-driver perceived value formula (Hormozi's "Value Equation"): Dream Outcome × Perceived Likelihood of Achievement ÷ (Time Delay × Effort & Sacrifice). Use this skill when an offer is underpriced relative to its actual value, getting price objections, or failing to convert despite being genuinely good. Scores each driver on a binary 0/1 rubric, identifies which drivers are dragging value down, and produces concrete improvement actions for each weak driver. Triggers include: "why won't people pay for this?", "how do I raise my price?", "my offer isn't converting", "I need to make my service more compelling", "how do I justify my premium", "should I be charging more?", "what makes my offer valuable?", "how do I compete against cheaper alternatives?". Applies to: consulting, coaching, courses, agencies, productized services, physical products, SaaS, any offer where perceived value determines willingness to pay.
Influence Defense Analyzer
Detect and counter manipulation attempts using Cialdini's 6 influence principles. Use when you feel pressured to comply with a request, sense a sales tactic at work, want to audit a document for manipulation, or ask "is this legitimate or am I being played?" Also use for: analyzing a sales pitch, marketing email, negotiation transcript, or contract for exploitative influence tactics; identifying which compliance trigger is being activated and whether it's real or manufactured; deciding whether to comply with a request you feel uneasy about; auditing your own persuasive content for ethical compliance; training yourself to recognize manipulation in consumer, negotiation, or organizational contexts. Applies all 6 per-principle defense protocols (reciprocity, commitment/consistency, social proof, liking, authority, scarcity) plus the epilogue meta-framework to classify practitioners as fair (real evidence) or exploitative (manufactured triggers) and prescribe a principle-specific response strategy. Works on document sets — sales pitches, marketing claims, negotiation transcripts, contracts, advertising — as well as live compliance scenarios described in text.
Influence Principle Selector
Identify which of Cialdini's 6 influence principles to apply for a persuasion scenario. Use when someone asks "which persuasion tactic should I use?", "how do I make this more persuasive?", "what's the best influence strategy for this situation?", or "which Cialdini principle applies here?" Also use for: persuasion audit of marketing copy, sales email, or landing page; choosing between reciprocity vs scarcity vs social proof for a campaign; mapping a persuasion scenario to compliance psychology; diagnosing why content isn't converting; identifying influence tactics being used against you in a negotiation; evaluating ethical boundaries of a persuasion approach. Applies Cialdini's master taxonomy of 6 principles (reciprocity, commitment, consistency, social proof, liking, authority, scarcity) plus contrast principle and cross-principle interaction rules to produce a scored, rationale-backed recommendation. Classifies practitioners as ethical (real evidence) vs exploitative (manufactured triggers). Works on marketing strategy, sales psychology, copywriting, product onboarding, negotiation briefs, and any compliance scenario.
Retrieval Practice Study System
Design a complete self-quizzing study system for any subject, course, or learning goal. Use this skill whenever the user wants to study more effectively, stop wasting time rereading notes, build a study schedule from learning material, prepare for exams, create flashcard decks with a spacing system, design a practice-quiz regimen, or turn any document into a retrieval-based learning plan — even if they don't mention "retrieval practice" or "spaced repetition." Works for students at any level, professionals upskilling, lifelong learners, and coaches designing training programs. Do NOT use this skill to evaluate whether a textbook or course is good (that is a different task), or to build automated quiz software (that requires a coding skill).
Structured Reflection Protocol
Run a structured reflection or debrief after any learning experience, project, procedure, or performance to turn raw experience into durable skill. Use this skill whenever the user wants to do an after-action review, write a learning journal entry, debrief a session, run a post-mortem, reflect on what went well and what to improve, turn a recent experience into a lesson they will remember, create a reflection document after completing a course chapter or training, or consolidate learning from a recent event — even if they do not use the words "reflection" or "retrieval." Works for students, professionals, coaches, clinicians, writers, teachers, and anyone learning from experience. Do NOT use this skill to build a spaced repetition quiz system (use retrieval-practice-study-system) or to analyze an external document for content (use a different skill).
Seam Type Selector
Select the right seam type (Preprocessor / Link / Object) for breaking a dependency in legacy code. Use whenever a developer needs to substitute behavior for testing without editing in place, is choosing between dependency-injection strategies in an existing codebase, or asks 'how do I intercept this call in a test' / 'how do I fake this library' / 'how do I test around this hard-coded dependency'. Activates for 'seam', 'test seam', 'substitution point', 'dependency injection for legacy code', 'mock this without DI framework', 'C++ testing', 'linker-level fake', 'preprocessor substitution', 'polymorphic substitution', 'enabling point'.
Scarcity And Urgency Tactics
Add scarcity and urgency layers to a completed offer to increase conversion rate and perceived value without changing the offer itself. Use this skill when you have a defined offer but conversion is sluggish, when prospects say "I'll think about it" or "maybe later," when you are launching a promotion and need a legitimate reason to act now, or when you want to build pent-up demand between sales cycles. Scarcity limits quantity (how many can buy); urgency limits time (when they can buy). Used together they create the psychological conditions where action now is more compelling than waiting. Trigger phrases: "how do I get people to buy now", "how do I stop prospects from procrastinating", "add urgency to my offer", "create scarcity for my service", "how do I run a limited-time offer", "set up a launch deadline", "get more people off the fence", "use fear of missing out", "make my offer feel exclusive", "why aren't people buying after the call", "how do I fill my cohort faster", "people keep saying they'll think about it". Applies to: coaching, consulting, group programs, online courses, agencies, local services, physical products, SaaS trials, any business that takes new clients or customers. Run this skill after `grand-slam-offer-creation`. Layer on top of output from `bonus-stacking-system` and `offer-naming-magic-formula` before going live.
Bonus Stacking System
Build and present a bonus stack that makes your core offer feel irresistible by applying an 11-point bonus quality checklist, a before/after-objection deployment sequence for one-on-one sales, and a 3-step partner bonus system that sources free high-value bonuses from adjacent businesses. Use this skill when your grand slam offer is drafted and you need to increase perceived value without discounting the price; when prospects stall at close and you need a structured way to layer bonuses against their specific objections; when you want to source third-party bonuses at zero cost and turn them into affiliate revenue; or when you need a complete bonus stack document with named bonuses, assigned values, and a presentation sequence ready for use in sales conversations.
Grand Slam Offer Creation
Build a complete, differentiated offer bundle from scratch using a 5-step process: define the target customer's dream outcome, map every obstacle they face, convert those obstacles into named solution components, select the highest-value delivery formats for each, then trim low-value items and stack the remainder into a final offer with assigned dollar values and a single price. Use this skill when starting a new offer, when an existing offer is being commoditized (competing on price), when conversion is poor despite genuine quality, or when a business needs to escape the "race to the bottom" pricing dynamic. Trigger phrases: "how do I create an offer", "build me a product", "what should I include in my offer", "how do I stop competing on price", "design a new service package", "make my offer irresistible", "what should my program include", "how do I package my services", "what should I charge for", "create an offer from scratch", "help me build a coaching program", "escape commoditization". Applies to: coaching, consulting, agencies, courses, productized services, gyms, clinics, SaaS, any business where the offer structure determines price and conversion. This is the hub skill for offer creation — run it before guarantee design, bonus stacking, scarcity/urgency framing, or offer naming.
Inheritance Mapping Selector
Select the correct ORM inheritance strategy — Single Table Inheritance (STI), Class Table Inheritance (joined table / Multi-Table Inheritance), or Concrete Table Inheritance (table per class) — for any OO inheritance hierarchy that needs to be persisted in a relational database. Use when asked: "which inheritance mapping should I use?", "single table vs joined table inheritance", "STI vs CTI vs table per class", "Hibernate inheritance strategy SINGLE_TABLE vs JOINED vs TABLE_PER_CLASS", "@Inheritance JPA", "Rails STI vs multi-table inheritance", "Django model inheritance type", "how to map inheritance in database", "inheritance in database design", "discriminator column inheritance", "ORM polymorphic query performance", "polymorphic table design", "table per class inheritance trade-offs", "joined inheritance vs single table", "inheritance schema design". Applies at greenfield schema design, ORM configuration, or legacy schema refactoring. Routes to the right strategy on six trade-off dimensions: joins on polymorphic read, wasted column space, FK-constraint enforceability, ad-hoc query readability, refactoring impact, and polymorphism-query cost. Identifies when mixing strategies via Inheritance Mappers is warranted (hierarchy branches with divergent trade-offs). Maps each strategy to idiomatic ORM config: Hibernate/JPA `@Inheritance(SINGLE_TABLE/JOINED/TABLE_PER_CLASS)`, Rails STI type column, Django Multi-Table Inheritance vs abstract base. Produces an inheritance mapping decision record with schema sketch and ORM config snippet.
Lazy Load Strategy Implementer
Implement Lazy Load (deferred loading) correctly in a persistence layer to avoid N+1 queries, ripple loading, and proxy identity traps. Use when encountering slow object graph loads, N+1 query problems, out-of-memory on eager loading, ORM lazy loading misconfiguration, or deciding between eager vs lazy loading strategies. Applies to: Hibernate FetchType.LAZY / @BatchSize, SQLAlchemy lazy='select'/'selectin'/'subquery', Django select_related / prefetch_related, EF Core Include() vs Load(), TypeORM eager/lazy relations, Rails includes/preload/eager_load, hand-rolled Data Mapper with virtual proxy patterns. Covers all four implementation variants — lazy initialization, virtual proxy, value holder, ghost — with applicability rules and trade-off analysis. Identifies and fixes the ripple loading anti-pattern (N+1 on collections), the proxy identity trap (two proxies, same row, broken equality), and misuse of Lazy Load on small graphs that should just be eagerly loaded. Produces an implementation plan: chosen variant, ORM configuration or code sketch, batch loading config, eager-load overrides for hot paths, Identity Map integration, and a ripple-loading audit. Requires knowing the data-source pattern already in use (Data Mapper / ORM vs Active Record); if unknown invoke data-source-pattern-selector first.
Optimistic Offline Lock Implementer
Use when offline-concurrency-strategy-selector (or your team) has chosen Optimistic Offline Lock and you need to implement it correctly end-to-end. Handles: adding a version column (integer, not timestamp), version-conditioned UPDATE and DELETE SQL (WHERE id=? AND version=?), row-count-zero collision detection, ConcurrencyException with modifiedBy+modified context, stale-version prevention, version round-tripping from server to client and back, Unit of Work commit integration (checkConsistentReads → insertNew → deleteRemoved → updateDirty with rollback on exception), ORM-native version support (@Version annotation JPA/Hibernate, [ConcurrencyCheck] or [Timestamp] EF Core, version_id_col SQLAlchemy, lock_version Rails, django-concurrency), and collision UX design (merge / force-save / abandon — not just a 409 error). Also handles: optimistic locking, optimistic offline lock, concurrent edit collision detection, lost update prevention, conditional update, concurrency version check, OptimisticLockException, DbUpdateConcurrencyException, StaleObjectError, inconsistent read protection, checkCurrent early-failure, anti-pattern audit (missing WHERE clause, non-incremented version, stale in-memory object retry, timestamp versioning). Produces an implementation plan covering schema, ORM config, version round-trip path, collision UX spec, test plan, and anti-pattern checklist.
Web Presentation Pattern Selector
Select the right web presentation pattern combination for any server-side web layer under design or refactor. Covers MVC (Model View Controller) decomposition, all three view patterns (Template View, Transform View, Two Step View), all three controller patterns (Page Controller, Front Controller, Application Controller), and when to layer Application Controller above the others for wizard or state-machine flows. Use when designing a new web layer, refactoring a tangled web controller, diagnosing fat controller or Template View scriptlet anti-patterns, mapping legacy JSP/ERB/ASP patterns to modern equivalents (Spring DispatcherServlet = Front Controller, Rails Router = Front Controller, JSP/ERB/Jinja = Template View), or deciding whether a wizard flow needs an Application Controller above a Front Controller. Applies to any language/framework: Java Spring MVC, Ruby on Rails, Python Django/Flask, ASP.NET Core, Node.js Express, PHP Laravel. Produces a web presentation design record with pattern selections, anti-pattern audit, and framework-specific implementation notes. Relevant keywords: web controller pattern, MVC, Model View Controller, Page Controller, Front Controller, Application Controller, Template View, Transform View, Two Step View, web presentation pattern, web framework architecture, refactor controllers, fat controller, server-side rendering, server-side MVC.
Profiling Driven Performance Optimization
Optimize code performance by first refactoring to a well-factored structure, then running a profiler to find actual hot spots, and applying targeted optimizations only where the profiler points — never by guessing. Use this skill when users report the program is too slow, before any performance work begins on an unfactored codebase, or after refactoring is complete and performance must now be tuned to acceptable levels.
Liking Factor Engineer
Analyze and engineer liking to increase rapport, persuasion, and compliance in marketing, sales, and communication contexts. Use this skill when the user wants to improve how much an audience likes them, their brand, or their message — including writing sales copy, designing onboarding flows, crafting brand voice, building personal brand, creating relationship-based sales strategy, writing endorsement copy, structuring ad creative, designing UX that builds trust, or preparing for any high-stakes pitch or persuasion scenario. Also use when the user suspects they are being manipulated by a compliance professional through manufactured rapport, flattery, or contrived similarity. Trigger keywords: liking, rapport, trust, relationship building, brand personality, personal brand, similarity, compliments, familiarity, association, endorsement, halo effect, attractive design, influence, persuasion, likability, warm, friendly, relatable, connection.
Multi Principle Stacking Planner
Design a layered persuasion campaign by combining 2–4 Cialdini influence principles in the right sequence. Use when someone asks "how do I combine influence principles?", "what's the best stacking order for my campaign?", "I want to use reciprocity AND scarcity — in what order?", or "how do I build a multi-touch persuasion sequence?" Also use for: designing a launch funnel that layers social proof onto scarcity, building a sales sequence that converts cold leads to committed buyers, creating an in-person event with maximum compliance architecture, auditing a multi-step campaign for principle interaction errors, planning a persuasion sequence for high-ticket or complex sales. Applies Cialdini's documented stacking patterns (Tupperware, Christmas toy tactic, Good Cop/Bad Cop, Regan override study) plus derived interaction rules — which principles amplify each other, which override each other, and which must be sequenced in a specific order. Covers: principle interaction rules, stacking sequences, contrast amplification, structural amplifiers, and ethical stacking thresholds. Outputs a sequenced campaign plan with WHY reasoning for each layer. Depends on influence-principle-selector (for principle scoring) and all 6 principle skills (for per-principle implementation). Best for experienced marketers, campaign strategists, and sales leaders working on multi-touch sequences, launch funnels, or complex sales architectures.
Practice Schedule Designer
Design a concrete practice schedule that will actually make learning stick — not just feel productive. Use this skill when the user is preparing for a test, building a new skill, training others, or planning a study program and needs to decide how to structure practice sessions over time. Triggers include: user is relying on marathon study sessions or cramming before a deadline; user practices one topic exhaustively before moving to the next; user feels they know material during practice but forgets it on tests or in real situations; user wants to know how often to review flashcards or revisit past material; user needs to design a training curriculum for a team or class; user is switching between topics during study and wants to know if that is helping or hurting; user is preparing for a performance context (exam, job, sport) and must choose between depth on one skill versus breadth across many. This skill does NOT address memorization technique or recall strategy — use retrieval-practice-study-system for those.
Guarantee Design And Selection
Design, select, and word a risk-reversal guarantee for a product or service offer. Use this skill when the user wants to add a guarantee to an offer, asks "what kind of guarantee should I offer," says prospects are hesitant or objecting to the price or risk, wants to reduce refund fear without killing conversion, asks how to guarantee results, wonders whether to offer a money-back guarantee, wants to switch from a retainer pricing model to a performance model, needs to improve offer conversion rate, asks "what happens if they don't get results," wants to stack multiple guarantees, or is designing a new high-ticket offer and needs a risk-reversal mechanism — even if they don't explicitly mention "guarantee" or "risk reversal." This skill produces a guarantee recommendation with type, wording, and ROI projection. For building the full offer stack see grand-slam-offer-creation. For auditing perceived value before writing the guarantee see value-equation-offer-audit.
Legacy Code Symptom Router
Diagnose any legacy-code situation in plain language and route to the right technique. Use as the FIRST skill when a developer has a vague or specific complaint about a codebase — 'I have to change this but there are no tests', 'this method is huge', 'can't test this class', 'library is killing us', 'changes take forever', 'don't know where to start', 'overwhelmed', 'inherited this mess'. Activates for 'legacy code', 'untested code', 'where do I start', 'what should I do with this code', 'help me plan a refactor', 'I'm stuck with legacy', 'how do I change X safely', 'symptom triage'. Dispatches to technique-specific skills.
Offer Naming Magic Formula
Apply when you need to name a new offer, program, service, or promotion — or when an existing offer's response rate has dropped and you suspect the name is the bottleneck. Generates 3-5 testable offer name variants using the five-component naming framework (magnetic reason, target audience, goal, time interval, container word) and produces a prioritized offer refresh plan to combat audience fatigue.
Acquisition Channel Selection Scorer
Use this skill to choose acquisition channels for a post-PMF product using the Balfour 6-factor scoring matrix (Cost, Targeting, Control, Input Time, Output Time, Scale — each rated 1–10). First runs two diagnostic prerequisites: language/market fit (does your copy resonate?) and channel/product fit (do your channels match how your audience discovers products?). Then classifies candidate channels into viral/word-of-mouth, organic, and paid categories; scores each on the 6 factors; and recommends 2–3 channels for a Discovery phase with explicit graduation criteria to an Optimization phase. Triggers when a growth PM asks 'which acquisition channels should I test?', 'should I do Facebook ads or SEO?', 'help me pick growth channels', 'acquisition channel prioritization', 'channel/market fit', 'Balfour channel framework', 'our paid ads aren't working', 'which channels for B2B SaaS', 'which channels for e-commerce', 'which channels for consumer app', 'acquisition strategy', or 'how do I pick channels'. Also activates for 'we're spreading too thin across channels', 'single channel focus', 'channel diversification', 'Peter Thiel one channel', 'discovery phase channels', 'channel scoring matrix', or 'six factor channel framework'.
Activation Funnel Diagnostic
Use this skill to diagnose where in an activation funnel users drop off and decide between removing friction or adding 'positive friction' (guided steps) to fix it. Maps the route from signup to the aha moment (first core-value experience), builds a channel-segmented funnel conversion report from metrics data, identifies the highest-drop-off step, interprets user survey data at drop-off points, and emits an activation-funnel-diagnosis.md plus a ranked list of activation experiment candidates. Triggers when a growth PM asks 'why are users signing up but not coming back?', 'our activation rate is terrible', 'where are users dropping off in onboarding?', 'activation funnel audit', 'users don't reach aha moment', 'onboarding diagnosis', 'NUX problems', 'first-run experience broken', 'how do I find friction', 'should I simplify or guide my onboarding?', or 'help me diagnose my activation'. Also activates for 'funnel analysis', 'drop-off diagnosis', 'desire friction conversion', 'magic moment audit', 'Twitter 30 follows pattern', or 'Facebook 7 friends rule'.
Growth Experiment Prioritization Scorer
Use this skill to score and rank a growth experiment backlog using the ICE framework (Impact, Confidence, Ease — each rated 1–10 and averaged) and select the top experiments for the next sprint. Reads an experiment-backlog.md file, applies the ICE rubric with explicit definitions for each dimension, ranks all experiments, separates 'launch now' from 'pipeline with target date' from 'drop', and emits a scored backlog the team can bring to their weekly growth review. Triggers when a growth PM asks 'help me prioritize my experiment ideas', 'which test should I run next', 'ICE score my backlog', 'rank these growth experiments', 'how do I pick experiments for this sprint', 'impact confidence ease', 'ICE framework', 'growth experiment prioritization', or 'I have 40 test ideas, which ones first'. Also activates for 'score this backlog', 'my experiment queue is a mess', 'we keep running low-impact tests', 'growth experiment ranking', or 'how to rank A/B test ideas'.
Growth Stall Prevention
Use this skill to run a quarterly audit on a growth program to detect and prevent growth stalls — the 18-month plateau that affects 87% of companies (HBR) and destroys 74% of their market cap. Reviews the North Star metric trend, channel concentration, experiment volume/cadence decay, and names the stall pattern (complacency / premature lever exit / channel dependency) with specific recovery actions. Consumes metrics history + experiment log from an existing growth operating system. Triggers when a growth lead or Head of Growth asks 'our growth has plateaued', 'we were growing then stopped', 'growth stall', 'why did our growth slow down', 'growth stall audit', 'are we at risk of stalling', 'our channels are saturating', 'experiments are slowing down', 'we keep running the same tests', 'virtuous growth cycle', 'how do I sustain growth', 'Skype growth stall', 'HBR growth stall research', or 'quarterly growth check-up'. Also activates for 'we're 18 months in and growth is flat', 'channel dependency', 'growth engine breakdown', or 'how do we reinvigorate growth'. Run this skill quarterly — stalls are preventable, but only if detected early.
Growth Team Structure Planner
Use this skill to design a cross-functional growth team for a Series A–B scaling startup and produce a concrete proposal the growth lead can bring to their executive team. Recommends product-led (growth team embedded in product) vs independent (standalone growth team reporting to CEO or VP Growth) based on org context, assigns named roles (growth lead, PM, engineer, designer, data analyst, marketer), defines executive sponsorship requirements, and drafts a kickoff meeting agenda. Triggers when user asks 'how do I structure a growth team?', 'should growth be under product or standalone?', 'who should be on my growth team?', 'what roles does a growth team need?', 'how do I pitch a growth team to my CEO?', 'growth team kickoff', 'first growth hire', 'growth team model', or 'building a growth team from scratch'. Also activates for 'our marketing and product aren't aligned on growth', 'we need a growth function but don't know how to structure it', 'growth team charter', or 'growth team proposal'.
High Tempo Experiment Cycle
Use this skill to install a disciplined weekly experimentation cadence for a growth team — the 4-stage high-tempo cycle (Analyze, Ideate, Prioritize, Test) with a timeboxed growth review meeting agenda, idea capture template, and cadence benchmarks. Produces an experiment-cycle-runbook the team can follow from Monday morning, a weekly growth review agenda with named roles and materials, and an idea capture template that feeds the prioritization queue. Triggers when a growth PM asks 'how do I run a weekly growth meeting?', 'our experiments are ad-hoc, how do we systematize?', 'growth meeting agenda', 'high-tempo testing', 'experiment cadence', 'how often should we test?', 'how many experiments per week?', 'weekly growth review', 'Sean Ellis growth meeting', 'growth cycle', 'growth rituals', 'how do I install a test rhythm', or 'our growth team has no rhythm'. Also activates for 'we keep running tests but nothing compounds', 'scattershot experiments', 'growth team operating system', or 'idea bank template'.
Monetization Experiment Planner
Use this skill to plan monetization experiments for a post-PMF product with stable retention — classify the monetization archetype (subscription / e-commerce / ad-revenue), run cohort revenue analysis to find highest-value customer segments, and propose pricing experiments using pricing relativity (3-tier anchoring), cohort upsell, and penny-gap handling. Produces a monetization-experiment-backlog.md with ordered tests and a revenue-cohort-analysis.md showing where the revenue actually comes from. Triggers when a growth PM asks 'how do I increase revenue per user', 'pricing experiment ideas', 'should I raise my prices', 'how do I structure pricing tiers', 'pricing anchoring', 'cohort revenue analysis', 'freemium to paid conversion', 'penny gap problem', 'our LTV is too low', 'CAC LTV ratio', 'monetization funnel', 'upsell experiments', or 'how do I monetize my free users'. Also activates for 'should we drop the price', 'three tier pricing', 'Qualaroo pricing case', or 'personalization recommendations revenue'.
North Star Metric Selector
Use this skill to construct a growth equation for a product and select a defensible North Star Metric that actually reflects core value delivery — rejecting vanity metrics (DAU, total signups, pageviews) that feel like growth but don't compound. Produces the full multiplicative growth equation (acquisition × activation × retention + monetization + referral) and a scored shortlist of NSM candidates with rationale, then recommends one. Triggers when a growth PM or head of growth asks 'what should our north star metric be?', 'help me pick a north star', 'is DAU the right metric?', 'my team is chasing vanity metrics', 'we're orienting around the wrong metric', 'how do I build a growth equation', 'what's our key growth metric', 'OMTM one metric that matters', 'north star framework', or 'growth equation for [product type]'. Also activates for 'WhatsApp messages sent as north star', 'Airbnb nights booked', 'north star vs input metrics', or 'why DAU is misleading'. Use AFTER product/market fit is confirmed — this metric orients every downstream growth experiment.
Product Market Fit Readiness Gate
Use this skill to determine whether a product is ready for scaled growth experimentation BEFORE investing in acquisition, activation, or retention hacks. Runs the Sean Ellis must-have survey (40% 'very disappointed' threshold), analyzes retention curve stability, and outputs a binary go/no-go verdict with remediation protocol for failing products. Triggers when a growth PM asks 'are we ready to scale?', 'should we invest in acquisition yet?', 'do we have product/market fit?', 'is my product must-have?', 'should we hire a growth team?', or 'why are our experiments not working?'. Also activates for 'how do I run the Sean Ellis test', 'must-have survey', 'product/market fit check', 'retention curve analysis', 'PMF gate', or 'premature scaling check'. Use BEFORE any other growth skill — this is the gate.
Retention Phase Intervention Selector
Use this skill to diagnose which retention phase (initial / medium / long-term) is broken for a user cohort and select the RIGHT type of intervention for that phase — because retention tactics that work for week-1 users fail completely for month-6 users. Reads cohort retention data, classifies the phase using product-type benchmarks (mobile ~1 day, SaaS ~1 month, e-commerce ~90 days), identifies where the curve breaks, and prescribes phase-appropriate hacks: aha-moment optimization for initial, habit formation + variable rewards for medium, feature velocity + ongoing onboarding for long-term. Includes a resurrection branch for dormant users and flags the churn-masking-by-acquisition anti-pattern. Triggers when a growth PM asks 'users churn after the first week', 'our month 2 retention drops off a cliff', 'retention is bad but I don't know why', 'cohort analysis help', 'how do I improve retention', 'retention curve diagnosis', 'initial vs long-term retention', 'Balfour three-phase retention', 'habit formation', 'variable rewards Hooked', 'zombie users resurrection', 'win-back campaign', 'feature bloat', or 'churn hidden by acquisition'. Also activates for 'my DAU looks good but retention is bad', 'we're growing but churning', or 'retention-first growth'.
Viral Loop Designer
Use this skill to design a viral or referral loop for a post-PMF product by extracting the PATTERN (not the tactic) from canonical case studies — Dropbox bilateral-incentive referral, Hotmail email-signature instrumented virality, Airbnb Craigslist cross-posting, LinkedIn public-profile SEO virality — and adapting it to the user's product. Classifies the mechanism type (word-of-mouth amplification, instrumented virality, embedded referral), models K-factor (invitations × conversion rate) and cycle time, and produces a viral-loop-design.md with the loop diagram plus a referral-test-plan.md for experiment execution. Flags the viral spam trap (when sharing becomes annoying and hurts the brand). Triggers when a growth PM asks 'how do I build a referral program like Dropbox?', 'viral loop design', 'how do I make my product viral', 'referral program', 'word of mouth growth', 'K-factor', 'viral coefficient', 'invite mechanism', 'should I offer referral rewards', 'bilateral incentive', 'Hotmail email signature', 'Airbnb Craigslist hack', 'LinkedIn public profiles', or 'viral loop testing'. Also activates for 'our referral program isn't working', 'viral spam trap', or 'refer a friend program design'.
Authority Signal Designer
Design and audit authority signals in content, credentials, bios, and landing pages. Use this skill when building expert positioning, thought leadership content, professional bios, about pages, or any content where trust and credibility must be established quickly. Covers three authority symbol types — titles, clothes/uniforms, and trappings — with compliance data showing their real-world persuasion impact. Also covers the two-question defense framework for evaluating authority claims you encounter. Applies strategic self-deprecation to build credibility. Use when: writing a professional bio, building a consultant's about page, crafting thought leadership content, designing a speaker or expert landing page, positioning credentials in marketing copy, adding expert testimonials or social proof of expertise, auditing whether your content actually conveys authority, or when evaluating whether an authority claim you're reading is genuine. Relevant for: authority, credibility, expertise, thought leadership, credentials, trust signals, expert positioning, professional bio, about page, social proof of expertise, testimonials from experts, Milgram, obedience, compliance, persuasion.
Target Market Selection
Score and select a target market before building any offer. Use this skill when starting a new business, evaluating a niche, choosing between customer segments, questioning why an existing offer is underperforming despite good execution, or deciding how narrowly to specialize. Activates on phrases like "who should I sell to," "is this a good market," "should I niche down," "I'm not getting traction," "which audience should I focus on," or any request to validate, score, or compare potential target markets.
Mnemonic Device Selector And Builder
Build a complete mnemonic device or memory palace for anything the user needs to memorize, recall, or remember. Use this skill whenever someone wants to memorize a list, sequence, set of terms, vocabulary, historical dates, medical facts, or any body of material they struggle to recall. Activates on requests like "help me remember", "I can't recall", "memorize this", "make a mnemonic", "build a memory palace", "use method of loci", "create a flashcard structure", "remember in order", "recall under pressure", or "stop forgetting." Covers simple devices (acronyms, peg method, chunking, rhyme schemes) and complex devices (memory palace, method of loci, location-based recall). Does NOT teach the underlying subject matter — the learner must understand the content first; this skill organizes it for retrieval.
Adversary Profiling And Threat Modeling
Profile the likely adversaries targeting a system and produce a structured threat model with prioritized threat scenarios. Use when: designing a new system or service and need to identify who might attack it and how; evaluating whether existing security controls address the right threats; preparing a threat model document for a security review, compliance audit, or architecture decision record; assessing insider risk for a system that handles sensitive data or privileged operations; or mapping attack lifecycle stages to defensive controls. Applies the three adversary frameworks — attacker motivations, attacker profiles, and attack lifecycle stages — alongside a four-dimension actor-motive-action-target threat scenario matrix to produce ranked threat scenarios. Distinct from vulnerability assessment (which audits specific technical flaws) and penetration testing (which actively exploits weaknesses). Produces: adversary profile summary, insider risk matrix, threat scenario list ranked by likelihood and impact, and per-stage defensive control recommendations.
Disaster Risk Assessment
Use when you need to assess disaster risk for a system or organization, perform structured risk analysis before disaster planning, identify which disasters to plan for, build a prioritized risk register, quantify probability and impact of failure scenarios, or answer "what disasters should we prepare for and in what order."
Dos Defense And Mitigation
Design DoS-resistant systems or respond to an active denial-of-service attack. Use this skill when designing a new service and want to evaluate its attack surface and build in layered defenses, assessing whether a production system's architecture is DoS-hardened, investigating a traffic spike to determine whether it is an attack or a self-inflicted surge, detecting a client retry storm and needing to apply backoff and jitter fixes, building or reviewing a DoS mitigation system (detection + response pipeline), or deciding how to respond strategically to an ongoing attack without leaking information about your defenses to the adversary.
Incident Response Team Setup
Use when you need to set up an incident response team from scratch, design an IR team charter, define severity and priority models for incidents, create IR playbooks, build a structured testing program, design tabletop exercises, or answer "how do we build and validate our incident response capability."
Least Privilege Access Design
Analyze a system's access patterns and design least-privilege controls: classify data and APIs by risk, select the narrowest API surface for each operation, define authorization policies with multi-party approval for sensitive actions, establish emergency access override procedures, and optionally introduce a controlled-access production proxy. Use when reviewing access controls for an existing system, designing authorization for a new service, auditing whether engineers have more permissions than their roles require, deciding whether to use a bastion or proxy for privileged operations, or hardening administrative API surfaces against insider mistakes and external compromise. Produces an access classification report, API surface recommendations, authorization policy decisions, and emergency override guidelines.
Recovery Mechanism Design
Design recovery mechanisms for a software system or component: select the right rollback control strategy from a three-mechanism decision framework (key rotation, deny list, and minimum acceptable security version number / downgrade prevention), set rate-of-change policy that decouples rollout velocity from rollout content, eliminate wall-clock time dependencies from recovery paths, design an explicit revocation mechanism with safe failure behavior (distributing cached revocation lists rather than failing open), and provision emergency access for use when normal access paths are completely unavailable. Use when designing a new system's update or rollback architecture, reviewing an existing release pipeline for security-reliability tradeoffs, defining rollback policy for self-updating firmware or system software, designing a revocation mechanism for credentials or certificates, or planning emergency access infrastructure before an incident occurs. Output: a recovery mechanism design document with rollback control strategy per component, rate-of-change policy, revocation mechanism design, and emergency access plan.
Resilience And Blast Radius Design
Design or audit a system's resilience posture using a layered framework — defense in depth, controlled degradation (load shedding vs. throttling), blast radius compartmentalization (role/location/time), failure domains, 3-tier component reliability hierarchy, and continuous validation. Use this skill when designing a new system for failure, reviewing an existing architecture for single points of failure, limiting blast radius of a potential attack or outage, deciding fail-open vs. fail-closed behavior for a component, or building an incident-response-ready compartmentalization strategy.
Secure Code Review
Review code for security vulnerabilities and reliability anti-patterns: scan for SQL injection risks (raw string concatenation into queries), XSS exposure (untyped HTML construction), authorization bypass from multilevel nesting, primitive type obsession, YAGNI-inflated attack surface, and missing framework enforcement for authentication/authorization/rate-limiting. Use when conducting a security code review, auditing a codebase for injection vulnerabilities, checking whether auth logic could be bypassed by nesting errors, evaluating whether RPC backends use hardened interceptor frameworks, or assessing whether type-safety patterns (TrustedSqlString, SafeHtml, SafeUrl) are applied to user-controlled inputs. Produces a categorized security findings report with severity, anti-pattern class, affected locations, and fix recommendations grounded in hardened-by-construction design.
Secure Deployment Pipeline
Secure a software deployment pipeline against supply chain attacks from benign insiders (mistakes), malicious insiders, and external attackers: map pipeline threats to mitigations using the three-adversary threat model, generate binary provenance requirements for each build stage, define provenance-based deployment policies with choke-point enforcement, design verifiable build architecture (trusted build service, rebuild service, or hybrid), and produce a staged hardening roadmap with breakglass controls. Use when assessing supply chain security for a CI/CD pipeline, implementing binary provenance to trace artifact origins, designing deployment policies that verify what is deployed rather than who initiated deployment, hardening build infrastructure against insider threats, or establishing breakglass procedures that remain auditable. Requires secure-code-review as a prerequisite control (code review is the first mitigation layer against malicious or accidental code changes before they enter the pipeline). Produces a deployment pipeline security assessment with threat-mitigation mapping, provenance schema, policy rules, and a phased hardening plan.
Security Change Rollout Planning
Plan and execute a security change rollout across a service or fleet: classify the change into a time horizon (short / medium / long-term), triage affected systems by risk tier, select the appropriate rollout strategy with canarying and staged deployment, define communication strategy (internal and external), set rollback and success criteria, and produce a written rollout plan. Use when you need to respond to a zero-day vulnerability, roll out a security posture improvement, or drive an ecosystem or regulatory compliance change. Handles timeline disruption scenarios: accelerate when an exploit goes public, slow down when patch instability is detected, delay when embargo, external dependency, or limited blast radius dictates caution. Produces a rollout plan with timeline, per-tier risk triage, communication strategy, and explicit rollback criteria. Examples covered: Shellshock emergency patch, hardware security key (FIDO/WebAuthn) company-wide deployment, and Chrome HTTPS migration.
Security Incident Command
Command and manage an active security incident from declaration through remediation handoff using the incident management framework (Google's IMAG, derived from ICS). Use when: you have a confirmed or suspected security incident and need to take command; someone says "we have a security incident" or "we may have been compromised"; you need to stand up an incident command structure with staffing roles; you are running forensic investigation and need to coordinate parallel tracks; an incident has grown large enough to require shift rotation and formal handovers; or you need to decide when investigation is complete enough to move to ejection and remediation. Distinct from incident response team setup (which designs the team and IR capability before incidents) — this skill executes the live response. Applies the seven-step incident command process: declare, staff, establish operational security, run forensic investigation loop, scale with rotation, apply the lead-rate decline signal to decide ejection timing, and hand off with a structured brief. Produces: incident state document, forensic timeline, communication plan, and remediation handoff package.
Security Incident Recovery
Use when you need to recover from a security incident, build an incident recovery plan, execute post-breach remediation, rotate credentials after a breach, scope attacker impact across systems, build a recovery checklist, decide when to eject an attacker vs. continue observing, or run a post-incident postmortem with short-term and long-term action items.
Security Reliability Design Review
Review a system design for security and reliability tradeoffs before implementation begins. Use when: evaluating an architecture proposal or design document and need to identify where security and reliability requirements conflict with feature or cost requirements; auditing a proposed design to determine whether security and reliability are designed in from the start or likely to require expensive retrofitting later; deciding whether to build payment processing or sensitive data handling in-house versus delegating to a third-party provider; assessing whether a microservices framework or platform incorporates security and reliability by construction rather than by convention; or producing a design review report for a security review, production readiness review, or architecture decision record. Applies the emergent property test (security and reliability cannot be bolted on — they must arise from the whole design), the initial-versus-sustained-velocity model (early neglect accelerates to later slowdown), and the Google design document evaluation checklist covering scalability, redundancy, dependency, data integrity, SLA, and security/privacy considerations. Produces: a design review report with identified tensions between feature, security, and reliability requirements; tradeoff recommendations; and prioritized security/reliability improvements. Distinct from threat modeling (which focuses on adversary scenarios) and code review (which audits existing implementation). Applicable at any stage where design decisions are still open.
Security Testing Strategy
Select and implement a layered security testing strategy for a codebase: design unit tests for security properties (boundary conditions, negative inputs, access control invariants), set up integration testing with non-production seed data (avoiding the production data copy anti-pattern), choose and configure dynamic analysis sanitizers (AddressSanitizer for memory corruption, ThreadSanitizer for race conditions, MemorySanitizer for uninitialized reads — with their performance cost tradeoff accounted for in CI/CD scheduling), plan fuzz testing (write effective fuzz drivers using libFuzzer/AFL, apply dictionary inputs for structured formats like HTTP/SQL/JSON, build a seed corpus, integrate continuous fuzzing via ClusterFuzz or OSS-Fuzz), and integrate static analysis at the right depth for each development stage (linters in the IDE commit loop, abstract interpretation nightly, formal methods for safety-critical paths). Use when creating a security testing plan for a new service, setting up fuzz testing for a parser or protocol implementation, integrating static analysis into a CI/CD pipeline, adding sanitizer-enhanced nightly builds, or auditing coverage gaps found during secure-code-review. Produces a security testing strategy document with tool selection rationale, CI/CD integration plan, and coverage priorities derived from code review findings.
Abstract Factory Implementor
Implement the Abstract Factory pattern to create families of related objects without specifying their concrete classes. Use when a system must be independent of how its products are created, when it must work with multiple product families, when products are designed to be used together and you need to enforce that constraint, or when providing a class library revealing only interfaces. Covers factory-as-singleton, prototype-based factories, and extensible factory interfaces.
Behavioral Pattern Selector
Choose the right behavioral design pattern from the 11 GoF behavioral patterns. Use when someone asks "how do I make this algorithm swappable?", "should I use Strategy or State?", "how do I decouple senders from receivers?", "what's the difference between Observer and Mediator?", "how do I add undo/redo?", "how do I traverse a collection without exposing its internals?", or "how do I add operations to classes I can't modify?" Also use when you see switch statements selecting between algorithms, tightly coupled event handlers, objects that change behavior based on state, or request-handling logic that should be distributed across a chain. Analyzes via two taxonomies — what aspect to encapsulate as an object (algorithm, state, protocol, traversal) and how to decouple senders from receivers (Command, Observer, Mediator, Chain of Responsibility) — with explicit trade-offs for each choice.
Bridge Pattern Implementor
Implement the Bridge pattern to decouple an abstraction from its implementation so both can vary independently. Use when you want to avoid a permanent binding between abstraction and implementation, when both abstractions and implementations should be extensible by subclassing, when implementation changes should not require recompiling clients, or when you need to share an implementation among multiple objects. Includes the evaluate-extremes design process (union vs intersection of functionality) and Abstract Factory integration for runtime implementation selection.
Command Pattern Implementor
Implement the Command pattern to encapsulate requests as objects, enabling parameterized operations, queuing, logging, and undo/redo. Use when you need to decouple UI elements from operations, implement multi-level undo with command history, support macro recording, queue or schedule requests, or log operations for crash recovery. Includes the complete undo/redo algorithm using a command history list with present-line pointer, MacroCommand for composite operations, and SimpleCommand template for eliminating subclasses.
Composite Pattern Implementor
Implement the Composite pattern to compose objects into tree structures representing part-whole hierarchies, letting clients treat individual objects and compositions uniformly. Use when building file systems, UI component trees, organization charts, document structures, or any recursive containment hierarchy. Addresses 9 implementation concerns including the safety-vs-transparency trade-off for child management, parent references, component sharing, caching, and child ordering.
Creational Pattern Selector
Choose the right creational design pattern (Abstract Factory, Builder, Factory Method, Prototype, or Singleton) for an object creation problem. Use when someone asks "which factory pattern should I use?", "should I use Abstract Factory or Factory Method?", "how do I create objects without specifying the concrete class?", "I need a factory but don't know which one", or "how do I make object creation flexible?" Also use when you see hard-coded `new ConcreteClass()` calls scattered throughout code, when product families must be swapped at runtime, when object construction is too complex for a single constructor, or when objects should be created by cloning a prototype. Compares patterns using two parameterization strategies — subclassing vs object composition — with trade-offs and an evolution path from Factory Method to more flexible alternatives.
Decorator Pattern Implementor
Implement the Decorator pattern to attach additional responsibilities to objects dynamically, providing a flexible alternative to subclassing. Use when you need to add behaviors like logging, caching, validation, authentication, compression, or UI embellishments without creating a subclass for every combination. Addresses the subclass explosion problem through transparent enclosure — decorators conform to the component interface so clients cannot distinguish decorated from undecorated objects. Covers composition order effects and the lightweight-decorator optimization. Triggers when: adding optional behaviors to objects at runtime, wrapping streams or middleware, layering cross-cutting concerns, needing to mix and match responsibilities without combinatorial subclass growth.
Design Pattern Selector
Select the right GoF design pattern for a specific object-oriented design problem. Use when facing any of these situations: object creation inflexibility (too many concrete class references), tight coupling between classes, subclass explosion from trying to extend behavior, inability to modify a class you don't own, need to vary an algorithm or behavior at runtime, want to add operations to a stable class hierarchy without modifying it, need to decouple a sender from its receivers, need undo/redo or event notification, or any time someone asks "which design pattern should I use?", "is there a pattern for this?", or "how do I design this more flexibly?" Analyzes the problem through 6 complementary selection approaches — intent scanning, purpose/scope classification, variability analysis, redesign cause diagnosis, pattern relationship navigation, and category comparison — to produce a scored pattern recommendation with trade-off analysis.
Multi Pattern System Designer
Design a system using multiple coordinated design patterns, moving beyond single-pattern application to pattern composition. Use when facing a complex system with multiple design problems — object creation inflexibility, structural rigidity, and behavioral coupling occurring simultaneously. Guides through the Lexi document editor methodology: decompose the system into design problems, map each to a pattern, identify pattern interaction points (e.g., Abstract Factory configures Bridge, Command uses Composite for macros, Iterator enables Visitor), and verify the patterns work together coherently.
Observer Pattern Implementor
Implement the Observer pattern to establish one-to-many dependencies where changing one object automatically notifies and updates all dependents. Use when a spreadsheet model needs to update multiple chart views, when UI components must react to data changes, when event systems need publish-subscribe, or when you need to decouple a subject from an unknown number of observers. Handles 10 implementation concerns including push vs pull models, dangling reference prevention, update cascade avoidance, and the ChangeManager compound pattern.
OO Design Principle Evaluator
Evaluate object-oriented designs against the two foundational GoF principles: 'Program to an interface, not an implementation' and 'Favor object composition over class inheritance.' Use when reviewing class hierarchies, assessing reuse strategies, or deciding between inheritance and composition for a specific design problem. Identifies violations like white-box reuse, broken encapsulation from subclassing, concrete class coupling, delegation overuse, and inheritance hierarchies that should be flattened. Use when someone says 'should I use inheritance or composition here', 'is this class hierarchy right', 'my subclass is breaking when the parent changes', 'how do I make this more flexible', 'is this design too rigid', 'I want to change behavior at runtime', or 'review my OO design for best practices'. Produces a design principle compliance report with specific violations and recommended refactoring.
OO Design Smell Detector
Detect common OO design smells in a codebase and recommend corrective design patterns. Use when reviewing code for design quality, investigating why changes are difficult, or auditing coupling and inheritance depth. Scans for 8 categories of design fragility — hardcoded object creation, operation dependencies, platform coupling, representation leaks, algorithm dependencies, tight coupling, subclass explosion, and inability to alter classes — each mapped to specific GoF patterns that fix them. Trigger when the user asks about design review, code smells, design anti-patterns, why a class is hard to change, why adding a feature requires modifying many files, class hierarchy review, inheritance overuse, why changes cascade, tight coupling, poor encapsulation, object creation rigidity, platform-dependent code, algorithmic coupling, or difficulty extending a third-party class.
Strategy Pattern Implementor
Implement the Strategy pattern to encapsulate a family of interchangeable algorithms behind a common interface. Use when you have multiple conditional branches selecting between algorithm variants, when algorithms need different space-time trade-offs, when a class has multiple behaviors expressed as conditionals, or when you need to swap algorithms at runtime. Detects the key code smell — switch/if-else chains selecting behavior — and refactors to Strategy objects.
Structural Pattern Selector
Choose the right structural design pattern (Adapter, Bridge, Composite, Decorator, Facade, Flyweight, or Proxy) for a structural design problem. Use when you need to adapt interfaces between incompatible classes, decouple an abstraction from its implementation so both can vary independently, build part-whole hierarchies where individual objects and compositions are treated uniformly, add responsibilities to objects dynamically without subclassing, simplify access to a complex subsystem, share large numbers of fine-grained objects efficiently, or control and mediate access to another object. Disambiguates commonly confused patterns: Adapter vs Bridge (timing — after design vs before design), Composite vs Decorator vs Proxy (intent — structure vs embellishment vs access control, recursion pattern). Also use when someone asks "should I use Adapter or Bridge?", "what's the difference between Decorator and Proxy?", "when should I use Facade vs Adapter?", or "do I need Flyweight here?"
Visitor Pattern Implementor
Implement the Visitor pattern to define new operations on an object structure without changing the classes of the elements it operates on. Use when you have a stable class hierarchy but frequently add new operations, when many unrelated operations need to be performed on an object structure, or when you want to accumulate state across a traversal. Includes the critical stability decision rule, double-dispatch mechanism (Accept/Visit), Iterator integration for traversal, and the encapsulation trade-off warning.
Batch Pipeline Designer
Design batch data processing pipelines for large-scale, bounded datasets processed offline. Use when building ETL workflows, processing logs or clickstream data at scale, generating ML feature pipelines or search indexes, or joining two large datasets that cannot fit in memory. Trigger phrases: "design a batch pipeline", "should I use Spark or MapReduce", "how do I join two large datasets", "build an ETL workflow", "process server logs at scale", "how do I handle skewed data in joins", "implement PageRank on a distributed graph", "design an offline processing job". Covers MapReduce vs dataflow engines (Spark, Flink, Tez), three join strategies (sort-merge, broadcast hash, partitioned hash) with selection criteria, graph processing via the Pregel/BSP model, and fault tolerance via materialization vs recomputation. Does not apply to unbounded input streams (see stream-processing-designer) or low-latency OLTP query serving. Produces a pipeline architecture recommendation with engine choice, join strategy, and fault tolerance approach.
Concurrency Anomaly Detector
Scan application code, SQL queries, or ORM code for exposure to the 6 database concurrency anomalies and produce a findings report with severity, affected locations, and fix recommendations. Use when: debugging a nondeterministic data corruption or race condition bug under concurrent load; auditing transaction code before deployment or after switching databases (isolation defaults differ across engines); a read-modify-write cycle or check-then-act pattern may be exposed to lost updates or write skew; an aggregate query (COUNT, SUM) guards an INSERT or UPDATE (phantom read exposure); or multiple tables are updated in one transaction without serializable isolation. Distinct from transaction-isolation-selector (which chooses the isolation level) — this skill scans code to find which anomalies existing code is already exposed to. Covers Python, Java, Go, JavaScript, Ruby; raw SQL; ORM code (SQLAlchemy, Hibernate, ActiveRecord, GORM); PostgreSQL, MySQL InnoDB, Oracle, SQL Server, and distributed databases. Maps code patterns (read-modify-write, SELECT/INSERT pairs, cross-table boundaries, snapshot boundary reads) to anomaly type, trigger conditions, and minimum fix (isolation upgrade vs. application-level mitigation).
Consistency Model Selector
Choose the correct consistency model (linearizability, causal consistency, or eventual consistency) for each operation in a distributed system, and select the matching implementation mechanism. Use when designing a new distributed data system, deciding whether ZooKeeper or etcd is needed for coordination, evaluating whether two-phase commit is appropriate for cross-node transactions, debugging correctness violations (stale reads, split-brain, uniqueness constraint failures), or distinguishing linearizability from serializability. Also use when applying the CAP theorem correctly (beyond the "pick 2 of 3" oversimplification), selecting total order broadcast as a consensus primitive, evaluating 2PC failure modes and lock-holding cost, or assessing whether causal consistency is sufficient in place of linearizability. Produces a per-operation consistency recommendation with replication mechanism, ordering guarantee, and — when consensus is needed — protocol selection (Raft, Zab, Paxos) with documented failure modes. Does not cover replication topology or failure recovery strategy (see replication-strategy-selector, distributed-failure-analyzer).
Data Integration Architect
Design the integration architecture for systems with multiple specialized data stores (Postgres, Elasticsearch, Redis, data warehouses) that must stay in sync. Use when deciding how data flows between components, avoiding dual writes, reasoning about correctness across system boundaries (idempotency, end-to-end operation identifiers), choosing between Lambda and Kappa architecture, or applying the "unbundling databases" pattern to compose specialized tools instead of relying on a single monolith. Trigger phrases: "how do I keep Postgres and Elasticsearch in sync?", "should I use CDC or event sourcing to propagate data?", "how do I avoid dual writes across microservices?", "my downstream systems are going out of sync — how do I fix the architecture?", "how do I design derived data pipelines?", "what is the system of record pattern?", "how do I integrate OLTP with a search index and an analytics warehouse?", "how do I design for end-to-end idempotency?". This is the capstone skill for data systems design — it synthesizes batch pipelines, stream integration, consistency, and replication into a single architecture recommendation. Produces a component map (systems of record vs derived views), data flow diagram, and correctness analysis. Does not replace batch-pipeline-designer or stream-processing-designer — delegates to them for pipeline internals.
Data Model Selector
Choose between relational, document, and graph data models for an application by analyzing data shape, relationship complexity, and query patterns. Use when asked "should I use MongoDB or PostgreSQL?", "when does a graph database make sense?", "how do I choose between SQL and NoSQL?", or "what data model fits my access patterns?" Also use for: evaluating impedance mismatch between data model and application code; deciding schema-on-read vs. schema-on-write for heterogeneous data; diagnosing whether many-to-many relationships call for relational or graph model; choosing between property graphs and triple-stores; deciding when polyglot persistence is appropriate. Produces a concrete recommendation with trade-off analysis — not "it depends." Covers relational (PostgreSQL, MySQL), document (MongoDB, CouchDB), and graph (Neo4j, Datomic) models including schema enforcement strategies and data locality trade-offs. For storage engine internals (LSM-tree vs B-tree), use storage-engine-selector instead. For OLTP vs. analytics routing, use oltp-olap-workload-classifier instead.
Distributed Failure Analyzer
Diagnose distributed system failures caused by network faults, unreliable clocks, or process pauses — and map each to its correct mitigation. Use when: a node is intermittently timing out with no clear network outage; a lock-holder or leader keeps acting after being declared dead (zombie leader / split brain via distributed locking, not replication topology — use replication-failure-analyzer for replica split brain); stale reads persist beyond expected replication lag; wall-clock-based lease checks or last-write-wins conflict resolution is producing data loss under clock skew; or cascading node-death declarations are occurring under load. Also use proactively to audit timing assumptions in new system designs (absence of fencing tokens, NTP drift exposure, GC pause risk). Distinct from replication-failure-analyzer (replication lag anomalies, failover pitfalls, quorum edge cases). Produces a structured failure report: symptom → fault category → mechanism → mitigation. Covers: asynchronous network behavior, timeout tuning and cascade risk, NTP drift and clock jump mechanics, process pause causes (GC, VM migration, paging, SIGSTOP), fencing tokens with ZooKeeper zxid/cversion, Byzantine fault scoping, and system model selection (crash-stop vs. crash-recovery vs. Byzantine; synchronous vs. partially synchronous vs. asynchronous).
Encoding Format Advisor
Select a data encoding format (JSON, Protobuf, Thrift, or Avro) and design a schema evolution strategy that preserves backward and forward compatibility through rolling upgrades. Use when asked "should I use Protobuf or JSON?", "how do I evolve my schema without breaking old clients?", "how does Avro schema evolution work?", "what's the difference between Thrift and Protocol Buffers?", or "how do I add/remove fields without breaking compatibility?" Also use for: choosing text vs. binary encoding for internal services; checking whether a schema change breaks compatibility; diagnosing unknown field loss bugs during rolling upgrades; planning per-dataflow encoding strategy (database storage vs. REST/RPC vs. message broker). Covers five encoding families: language-specific, JSON/XML/CSV, binary JSON, Thrift/Protobuf, and Avro — with writer/reader schema reconciliation and per-dataflow-mode analysis. For data model selection (relational/document/graph), use data-model-selector instead. For message broker or stream pipeline design, use stream-processing-designer instead.
Oltp Olap Workload Classifier
Classify a data workload as OLTP, OLAP, or hybrid, then recommend the appropriate database architecture — transactional database, dedicated data warehouse, or both with an ETL pipeline. Use when asked "should I use a data warehouse?", "why are my analytics queries slow on my production database?", "should I use Redshift/BigQuery/Snowflake?", or "can one database handle both transactions and reporting?" Also use for: designing star or snowflake schemas for analytics; deciding when column-oriented storage is appropriate; planning ETL pipeline structure between operational and analytical systems; evaluating whether HTAP (hybrid) databases fit a workload. For choosing between relational/document/graph models, use data-model-selector instead. For storage engine internals (LSM-tree vs B-tree), use storage-engine-selector instead. For batch/stream pipeline design, use batch-pipeline-designer or stream-processing-designer instead.
Partitioning Strategy Advisor
Select the right partitioning (sharding) strategy — range, hash, or compound key — and configure secondary indexes, rebalancing, and request routing for a distributed database. Use when: designing a partition key for a new system; diagnosing write hotspots on monotonically increasing keys (timestamps, auto-increment IDs); evaluating whether an existing sharding scheme supports required query patterns; choosing between document-partitioned (local) vs. term-partitioned (global) secondary indexes and weighing scatter/gather read costs against global index write amplification; or selecting a rebalancing approach (fixed partitions, dynamic partitions, proportional-to-nodes) and routing topology (gossip, ZooKeeper coordination, partition-aware client). Covers Cassandra compound primary key patterns for range queries within hash-distributed partitions, HBase/SSTables range partitioning, Riak consistent hashing, and MongoDB/Elasticsearch index partitioning. Distinct from replication-strategy-selector (topology and consistency) and data-model-selector (schema design). Produces a concrete recommendation: partition key, partitioning method, secondary index approach, rebalancing configuration, and routing topology. Depends on data-model-selector for schema and access pattern context.
Replication Failure Analyzer
Diagnose active replication failures by mapping symptoms to leader failover pitfalls, replication lag anomalies, or quorum edge cases — and produce a structured remediation plan. Use when: data just written disappears or shows stale on re-read (read-after-write violation); records appear and vanish on refresh (monotonic reads violation); causally related events appear in impossible order (consistent prefix reads violation); a failover produces duplicate primary keys, write rejections, or incorrect routing; two replica nodes are both accepting writes (split brain in replication topology — for split brain via distributed locking, use distributed-failure-analyzer); quorum reads return stale values despite w + r > n; or a sloppy quorum with incomplete hinted handoff is serving old data. Applies to PostgreSQL, MySQL (single-leader), Cassandra, Riak, Voldemort, DynamoDB (leaderless). Use replication-strategy-selector first if the topology has not yet been chosen. Produces: symptom → failure class → mechanism → mitigation report, leader failover checklist, replication lag anomaly guide, and quorum edge case catalog (six ways w + r > n still fails).
Replication Strategy Selector
Choose a replication topology (single-leader, multi-leader, or leaderless) and configure it correctly — including sync vs. async mode, quorum parameters (w + r > n), and consistency guarantees. Use when designing replication for a new system, configuring quorum values for Cassandra/Riak/DynamoDB, deciding how to handle multi-leader write conflicts, or comparing PostgreSQL/MySQL streaming replication vs. CouchDB multi-leader vs. Cassandra leaderless for your architecture. Also use for: selecting a conflict resolution strategy (last-write-wins vs. version vectors); designing multi-datacenter replication; choosing between WAL shipping, logical replication, and statement-based replication log formats. For diagnosing an existing replication failure (failover gone wrong, lag spike, quorum misconfiguration, split brain), use replication-failure-analyzer instead. For consistency model selection (eventual vs. causal vs. linearizable), use consistency-model-selector instead. For partitioning strategy, use partitioning-strategy-advisor instead.
Storage Engine Selector
Select the right storage engine architecture (LSM-tree, B-tree, or in-memory) for a database workload using a 7-dimensional scored trade-off analysis. Use when evaluating RocksDB vs InnoDB vs LevelDB, diagnosing write amplification in production, choosing between write-optimized vs read-optimized storage, selecting a compaction strategy (size-tiered vs leveled), or deciding whether to skip disk with an in-memory database. Also use for: comparing Cassandra vs PostgreSQL storage internals; justifying an existing engine choice to a team; assessing whether compaction pauses are causing latency spikes. Covers LSM-tree family (LevelDB, RocksDB, Cassandra, HBase), B-tree family (PostgreSQL, MySQL InnoDB, SQLite), and in-memory stores (Redis, Memcached, VoltDB). For choosing between relational/document/graph models, use data-model-selector instead. For OLTP vs. analytics routing, use oltp-olap-workload-classifier instead. For replication topology, use replication-strategy-selector instead.
Stream Processing Designer
Design a stream processing system for unbounded, continuously arriving data. Use when choosing a message broker (Kafka vs RabbitMQ), implementing change data capture (CDC) from PostgreSQL, MySQL, or MongoDB via Debezium or Maxwell, selecting window types for aggregation (tumbling, hopping, sliding, session), joining event streams or enriching events from a table, or configuring exactly-once fault tolerance. Trigger phrases: "should I use Kafka or RabbitMQ?", "how do I sync my database to Elasticsearch in real time?", "how do I implement CDC for Postgres?", "how do I get exactly-once semantics in Flink or Kafka Streams?", "should I use Lambda or Kappa architecture?", "how do I keep derived data systems in sync without dual writes?", "how do I join two event streams?". Covers log-based vs. traditional broker selection, four window types, three join types (stream-stream, stream-table, table-table), CDC bootstrap strategy, and microbatching vs. checkpointing trade-offs. Does not apply to bounded offline datasets (see batch-pipeline-designer) or multi-store integration architecture (see data-integration-architect).
Transaction Isolation Selector
Choose the correct transaction isolation level and serializability implementation for an application's concurrency patterns. Use when: selecting an isolation level for a new system; evaluating whether read committed or snapshot isolation is safe for your access patterns; deciding whether to upgrade to serializable and choosing between two-phase locking (2PL) vs. serializable snapshot isolation (SSI); producing an architecture decision record for isolation level choice; or explaining to a team why the database default is insufficient. Distinct from concurrency-anomaly-detector (which scans code for exposed anomalies) — this skill selects the level, not the bugs. Covers PostgreSQL, MySQL InnoDB, Oracle, SQL Server, and distributed databases. Applies a 6-anomaly × 4-isolation-level mapping matrix (dirty read, dirty write, read skew, lost update, write skew, phantom read vs. read uncommitted, read committed, snapshot isolation, serializable) to produce a concrete recommendation with implementation trade-off analysis. Works on any codebase, schema, or workload description.
Architect Control Calibrator
Determine the appropriate level of architect control over a development team using a quantitative 5-factor scoring model (-100 to +100 scale). Use this skill whenever the user asks how much they should be involved in a team's decisions, how hands-on or hands-off to be as an architect, how to calibrate their leadership style, whether they are micromanaging developers, whether they should give the team more autonomy, or any question about architect involvement level, team oversight, or technical leadership balance — even if they don't explicitly say "control." Also triggers when the user describes team dysfunction symptoms like merge conflicts increasing, nobody speaking up in meetings, or tasks falling through cracks.
Architect Role Assessor
Evaluate whether a software architect is fulfilling the 8 core expectations of the role and assess their technical breadth vs depth balance using the knowledge pyramid. Use this skill whenever the user asks what a software architect should be doing, questions whether they are performing the architect role correctly, wants to assess their own or someone else's architect performance, describes symptoms of role dysfunction (spending too much time coding, not attending stakeholder meetings, only recommending technologies they know, avoiding decisions), asks about transitioning from developer to architect, or encounters the Frozen Caveman anti-pattern where past experiences irrationally drive current decisions — even if they don't explicitly say "architect role" or "expectations."
Architecture Characteristics Identifier
Systematically identify, categorize, and prioritize architecture characteristics (quality attributes / -ilities) from requirements, domain concerns, and stakeholder input. Use this skill whenever the user is starting a new project, defining architecture requirements, translating business needs into technical characteristics, asking "what quality attributes matter?", figuring out nonfunctional requirements, or evaluating what -ilities to optimize for — even if they don't explicitly say "architecture characteristics."
Architecture Decision Record Creator
Create structured Architecture Decision Records (ADRs) with 7 sections to document architecture decisions with full justification. Use this skill whenever the user has made or needs to make an architecture decision, wants to document why a technical choice was made, is choosing between technologies or patterns, needs to create an ADR, or is experiencing repeated debates about past decisions — even if they don't explicitly mention "ADR" or "architecture decision record."
Architecture Diagram Creator
Create effective architecture diagrams following established diagramming standards (UML, C4, ArchiMate) with proper visual elements and presentation techniques. Use this skill whenever the user needs to create, review, or improve architecture diagrams, wants guidance on which diagramming standard to use, needs help with diagram elements (titles, lines, shapes, labels, color, keys), is preparing architecture presentations with slides, wants to use incremental builds for presenting complex diagrams, is struggling with inconsistent notation across diagrams, or needs to maintain representational consistency across different zoom levels of their architecture — even if they don't explicitly say "diagram."
Architecture Fitness Function Designer
Design automated governance mechanisms (fitness functions) that objectively measure and enforce architecture characteristics over time. Use this skill whenever the user asks about architecture governance, fitness functions, automated architecture testing, architecture compliance checks, preventing architecture erosion, enforcing layer dependencies, cyclomatic complexity thresholds, ArchUnit or NetArchTest rules, structural tests for architecture, CI/CD architecture gates, chaos engineering as governance, measuring architecture characteristics objectively, architecture drift detection, continuous architecture verification, or wants to ensure their codebase stays aligned with architecture decisions -- even if they don't use the term "fitness function."
Architecture Quantum Analyzer
Analyze a system's architecture quanta — independently deployable units with distinct quality attribute needs. Use this skill whenever the user needs to determine if their system should be monolith or distributed, is analyzing deployment boundaries, evaluating which parts of a system need different scalability/reliability/performance characteristics, decomposing a monolith, or asking "should this be one service or many?" — even if they don't use the term "quantum."
Architecture Risk Assessor
Quantify architecture risk using a 2D risk matrix (impact x likelihood, scored 1-9) and produce structured risk assessment reports. Use this skill whenever the user asks about architecture risks, wants to evaluate risk across services or components, needs a risk matrix, mentions risk assessment, risk analysis, risk heat map, risk scoring, or asks "what are the risks?" for any architecture — even if they don't explicitly say "risk assessment." Also triggers when the user mentions unproven technology risk, scalability risk, availability concerns, security risk, data integrity risk, or wants to prioritize risks for stakeholder meetings.
Architecture Style Selector
Guide the systematic selection of an architecture style by evaluating domain needs, architecture characteristics, quantum count, data constraints, and organizational factors against all major architecture styles (layered, pipeline, microkernel, service-based, event-driven, space-based, microservices). Use this skill whenever the user is choosing an architecture pattern, deciding between monolith and distributed, comparing architecture styles (e.g., "event-driven vs microservices"), asking "which architecture should we use?", starting a new system and considering options, or reconsidering their current architecture — even if they don't use the phrase "architecture style."
Architecture Tradeoff Analyzer
Systematically analyze trade-offs across quality attribute dimensions for architecture decisions. Use this skill whenever the user is comparing architecture options, weighing competing quality attributes (performance vs scalability, simplicity vs flexibility), making any structural technology decision, evaluating monolith vs distributed, choosing communication patterns, or asking "what are the trade-offs?" — even if they don't explicitly say "trade-off analysis."
Component Identifier
Decompose a system into well-defined components using structured discovery techniques. Use this skill whenever the user is designing a new system from requirements, breaking down a monolith into modules, deciding how to organize code into packages/services, asking "what components should this system have?", or struggling with component granularity — even if they don't use the word "component."
Development Checklist Generator
Create effective development checklists (code completion, unit/functional testing, software release) that teams will actually follow. Use this skill whenever the user needs to create a checklist for code review, testing, deployment, or release processes, wants to improve team quality by catching recurring mistakes, has a team that ignores existing checklists because they're too long, needs to define "definition of done" for development tasks, wants to reduce production incidents caused by human error, or asks about checklist best practices for software teams — even if they don't explicitly say "checklist."
Distributed Feasibility Checker
Evaluate whether a system should adopt distributed architecture by systematically checking against the 8 Fallacies of Distributed Computing and assessing team/operational readiness. Use this skill whenever the user is considering microservices, debating monolith vs distributed, hearing "let's use microservices," evaluating operational readiness for distribution, or experiencing growing pains with a monolith — even if they don't mention "distributed computing fallacies."
Event Driven Topology Selector
Choose between broker and mediator event-driven topologies based on workflow control needs, error handling requirements, and performance trade-offs. Use this skill whenever the user is designing an event-driven system, choosing between choreography and orchestration, deciding how events should flow between processors, debating broker vs mediator, building async workflows, evaluating event-driven error handling strategies, or comparing request-based vs event-based communication models — even if they don't use the terms "broker" or "mediator."
Microservice Granularity Optimizer
Right-size microservice boundaries using granularity disintegrators (forces to split: service scope, code volatility, scalability, fault tolerance, security, extensibility) and integrators (forces to combine: database transactions, workflow/choreography coupling, shared code, data relationships). Includes choreography vs orchestration selection and the saga pattern for distributed transactions. Use this skill whenever the user is splitting a monolith into microservices, deciding how fine-grained services should be, experiencing too many inter-service calls or latency from over-splitting, dealing with distributed transaction problems across microservices, choosing between choreography and orchestration for service communication, implementing the saga pattern, debugging a distributed monolith, or evaluating whether services should be merged or split further -- even if they don't use the exact phrase "microservice granularity."
Modularity Health Evaluator
Assess code modularity health using quantitative metrics — cohesion (LCOM), coupling (afferent/efferent), abstractness, instability, distance from main sequence, and connascence taxonomy. Use this skill whenever the user asks about module quality, code coupling analysis, cohesion measurement, class decomposition, package dependency analysis, LCOM scores, afferent/efferent coupling, connascence, zone of pain, zone of uselessness, extracting microservices from a monolith, evaluating module boundaries, dependency analysis, or wants to know if a class or package is well-structured — even if they don't use the term "modularity."
Risk Storming Facilitator
Plan and facilitate collaborative risk storming sessions for architecture teams. Use this skill whenever the user wants to run a risk identification workshop, organize a risk storming exercise, plan a collaborative risk assessment session, facilitate architecture risk discovery with a team, prepare a risk workshop agenda, coordinate group risk identification, or run a team-based architecture risk review. Also triggers when the user mentions "risk storming," "collaborative risk session," "team risk workshop," "group risk identification," wants to prepare pre-work materials for a risk meeting, or asks "how should I run a risk session with my team?" — even if they don't use the exact term "risk storming."
Service Based Architecture Designer
Design a service-based architecture with 4-12 coarse-grained domain services, including service decomposition, database partitioning strategy (shared vs domain-partitioned vs per-service), API layer design, and ACID vs BASE transaction decisions. Use this skill whenever the user is designing a service-based system, decomposing a monolith into coarse-grained services, deciding how many services to create, choosing a database topology for distributed services, deciding between shared database and per-service databases, evaluating whether to add an API layer, determining ACID vs eventual consistency needs, or comparing service-based architecture against microservices — even if they don't use the exact phrase "service-based architecture."
Stakeholder Negotiation Planner
Prepare architecture negotiation strategies for conversations with business stakeholders, other architects, and developers using proven techniques. Use this skill whenever the user needs to push back on unrealistic requirements, defend an architecture decision to management, convince a skeptical developer or senior engineer, navigate disagreements about technology choices, negotiate trade-offs between features and technical debt, deal with stakeholders who demand conflicting quality attributes, handle situations where someone with more authority or experience disagrees with their technical recommendation, or any situation requiring persuasion around architecture decisions — even if they don't explicitly say "negotiation."
Business Viability Stakeholder Testing
Test whether a product solution is viable for the business before building. Use when business viability risk is Medium or High, when multiple internal functions (legal, sales, finance, marketing) may have constraints on a proposed solution, when someone asks 'will this work for our business?', 'do we have stakeholder buy-in?', or 'does legal/finance/sales need to review this?' Also use when a proposed solution would change pricing, go-to-market motion, or support model, or when you need documented cross-functional sign-off before committing engineering resources. Identifies all stakeholders who can veto launch across 8 domains, conducts 1:1 preview sessions with high-fidelity prototypes, and resolves disagreements with evidence rather than opinions. Produces a structured viability sign-off document. Not for customer value testing — use value-testing-technique-selection. Not for product-market fit — use customer-discovery-program.
Customer Discovery Program
Design a customer discovery program to achieve product-market fit for a significant new product or market expansion. Use when launching a new product, entering a new market segment, redesigning a product for a different customer segment, or when someone asks 'how do we find product-market fit?', 'how do we get reference customers?', or 'are we stuck in a sales-driven fragmentation spiral?' Also use when the team is unsure if they have achieved product-market fit, when scaling sales feels premature, or when checking whether the Sean Ellis test applies. Produces a complete program plan: single target market definition, recruitment criteria for 6 reference customers, co-development relationship structure, and product-market fit definition by product type (B2B, platform/API, consumer, internal). Not for small features or minor improvements — use value-testing-technique-selection for those.
Discovery Framing Technique Selection
Select and execute the right discovery framing technique before building. Use when value risk is High and the underlying problem is not yet clearly defined, when a team is about to start discovery without a shared problem statement, when someone asks 'how should we frame this discovery effort?', or when starting any non-trivial feature, redesign, or new product effort. Also use for: writing an opportunity assessment, writing a customer letter (press release alternative), completing a startup canvas for a new business, or constructing a story map to scope discovery. Determines effort size (typical/large/new-product), selects the matching technique, and produces the framing document. Best triggered after product-discovery-risk-assessment. For specific testing techniques, use value-testing-technique-selection. For prototype selection, use discovery-prototype-selection.
Discovery Prototype Selection
Select the right prototype type and fidelity level for any discovery risk. Use when deciding what kind of prototype to build, when choosing between a feasibility spike, user prototype, live-data prototype, or Wizard of Oz prototype, or when someone asks 'what prototype should we build?' Also use when prototyping for usability testing, when validating a technical approach before building, when building a simulation for stakeholder alignment, or when an AI/ML feature needs pre-model validation. Maps the active risk (feasibility/usability/value/viability) to one of four prototype types and determines fidelity. Includes anti-pattern warnings for ambush estimation and prototype-as-value-proof confusion. Best triggered after product-discovery-risk-assessment. For executing usability or value tests after the prototype, use value-testing-technique-selection.
Product Culture Assessment
Assess the product culture of a company or team across innovation capacity and execution strength. Use when a leader, founder, or product manager wants to understand where the organization sits on the innovation-execution spectrum and which cultural gaps to address. Also use when someone asks 'do we have a strong innovation culture?', 'why does our team ship fast but feel uncreative?', 'how do we build a culture like Amazon or Netflix?', 'are we a feature factory?', or 'I need to assess our product culture before proposing changes.' Scores 14 culture attributes (7 innovation + 7 execution), places the organization in one of four quadrants (Dreamers, Factories, Elite, Stalled), and produces a prioritized 90-day improvement roadmap. For diagnosing specific team-level dysfunctions (velocity, design integration, behaviors), use product-team-health-diagnostic instead. For waterfall process issues, use product-process-dysfunction-diagnosis instead.
Product Discovery Risk Assessment
Assess product risks and decide whether to build. Use when starting product discovery, evaluating a new feature or product idea, deciding which risks to validate first, choosing between prototyping and testing approaches, or when someone asks 'should we build this?' Maps any idea to the 4-risk taxonomy (value risk, usability risk, feasibility risk, business viability risk) plus ethics risk, sequences discovery by priority, and selects the right technique category for each risk. Also use when a team is unsure what to validate next, when structuring a discovery sprint, or when planning pre-build validation activities. Hub skill for all downstream discovery technique selection — for specific techniques, use discovery-framing-technique-selection, discovery-prototype-selection, value-testing-technique-selection, customer-discovery-program, or business-viability-stakeholder-testing instead.
Product Manager Competency Assessment
Evaluate product manager competency for hiring, coaching, or self-assessment. Use when interviewing a VP of Product or head of product candidate, assessing an existing product leader, evaluating an individual contributor PM, conducting a PM self-assessment to find development gaps, or debriefing an interview panel. Also use when someone asks 'is this PM candidate strong?', 'am I a good product manager?', 'what does a strong VP of Product look like?', or 'how do I evaluate PM interview performance?' Covers VP assessment (team development, vision and strategy, execution, culture) and IC PM assessment (customer, data, business, market knowledge plus smart/creative/persistent traits). Diagnoses which of 3 PM working modes the person operates in: backlog administrator, roadmap administrator, or empowered PM. Not for team or organizational assessment — use product-team-health-diagnostic or product-culture-assessment for those.
Product Okr Implementation
Design and implement an OKR (Objectives and Key Results) system for product teams. Use when transitioning away from feature roadmaps to outcome-based planning, setting up OKRs for a product organization, replacing quarterly roadmaps with business objectives, aligning multiple teams to shared goals, or when someone asks 'how do we set up OKRs?' Also use when diagnosing OKR cascade failures, structuring high-integrity commitments to stakeholders, establishing OKR scoring standards, running quarterly OKR planning cycles, or scaling OKRs to 25+ teams. Covers the 12 OKR rules, scoring rubric, functional cascade anti-patterns, and a 6–12 month roadmap-to-outcomes transition plan. Not for diagnosing team health or culture — use product-team-health-diagnostic or product-culture-assessment instead.
Product Process Dysfunction Diagnosis
Diagnose why product efforts fail despite using Scrum, Agile, or roadmaps. Use when a team ships on time but customers don't adopt features, when leadership asks why there's no innovation despite an Agile process, when a new product leader needs to identify root causes quickly, or when someone asks 'are we doing waterfall disguised as Agile?' Also use when someone says 'we follow the process but nothing lands', 'sales keeps driving our roadmap', 'design is always scrambling to catch up', 'our engineers just build what they're told', or 'customers never adopt what we build.' Scores 10 root causes of product failure across startup, growth, and enterprise stages and produces a prioritized dysfunction report. For culture-wide assessment (innovation vs. execution), use product-culture-assessment. For team-level behaviors and velocity, use product-team-health-diagnostic.
Product Team Health Diagnostic
Diagnose why a product team or organization is slow, not innovative, or delivering poor outcomes. Use when a leader or team observes slow velocity, lack of innovation, poor product quality, feature factory behavior, or team dysfunction — and needs root causes and a prioritized fix list. Also use when a new product leader is assessing an organization, when a CEO or board says teams are too slow, or when someone says 'why are we not shipping faster?', 'engineering and design aren't collaborating', 'we ship but nothing moves the needle', or 'I need to assess team health before proposing changes.' Scores 42 diagnostic criteria across team behaviors, innovation capacity, velocity killers, and design integration. Produces a severity-ranked report with a composite health score and remediation priorities. For culture-level issues (innovation vs. execution quadrant), use product-culture-assessment. For process-level waterfall diagnosis, use product-process-dysfunction-diagnosis.
Product Vision Strategy Assessment
Assess or create a product vision and product strategy. Use when someone asks 'is our product vision strong enough?', 'does our strategy make sense?', 'we keep pivoting — is that a vision problem or a strategy problem?', or 'how do I write a compelling product vision?' Also use when diagnosing why teams lack direction or feel like mercenaries, stress-testing a strategy for focus and market sequencing, checking whether product principles are resolving design debates, or auditing an existing vision statement for ambition and inspiration gaps. Scores vision against 10 principles and strategy against 5 principles, identifies top gaps with specific rewrite guidance, and evaluates whether product principles exist and are functioning as guardrails. Works on vision documents, strategy decks, product plans, or verbal descriptions. Not for OKR setting — use product-okr-implementation. Not for team health or process issues — use product-team-health-diagnostic or product-process-dysfunction-diagnosis.
Value Testing Technique Selection
Select and execute the right value testing technique for product discovery. Use when you have a prototype and need to know if customers will actually choose or buy the product, when deciding between a fake door test, usability test, A/B test, or invite-only program, when someone asks 'how do we test if users want this?' or 'should we run an A/B test?', or when setting up analytics instrumentation before launch. Also use when validating demand before building anything, when choosing between qualitative vs. quantitative value testing, or when the team is unsure whether 'people said they liked it' is enough evidence. Covers the 3-level value testing hierarchy (demand / qualitative / quantitative), the usability-then-value session protocol, and the analytics instrumentation checklist. For prototype selection, use discovery-prototype-selection. For finding product-market fit with reference customers, use customer-discovery-program. For stakeholder viability sign-off, use business-viability-stakeholder-testing.
Concrete Language Rewriter
Rewrite abstract, theoretical, or jargon-heavy passages into sensory, schema-based language the audience can already picture — using three named techniques (schema tap, high-concept pitch, generative analogy). Use this skill whenever a draft sounds abstract, strategy-level, or theoretical and the user wants it grounded in concrete imagery the reader can see, hear, touch, or do. Activate when the user says "this sounds abstract", "make it more concrete", "feels jargon-y", "how do I explain this", "rewrite this pitch", "too theoretical", "simplify the language", "ground this", "make it tangible", "the reader can't picture it", "I'm stuck at the strategy level", "translate this into plain language", "make this vivid", "needs an analogy", "give me a one-liner pitch", "explain this to a 5-year-old", "we need a metaphor for this", or provides an abstract passage plus an audience and asks to concretize it. Also triggers when a mission statement, value prop, policy memo, product page, cultural value, onboarding doc, or training scenario reads like a thesaurus of abstractions (synergy, excellence, alignment, optimize, empower, leverage, robust, scalable, best-in-class). The skill does NOT invent fake sensory details to ground a claim the user has not actually made, does NOT score the whole SUCCESs rubric (that is the stickiness-audit skill), and does NOT write full narrative stories (that is the story-framing skill) — it produces a side-by-side before/after rewrite of each flagged abstract passage with the technique used and why.
Core Message Extractor
Extract the single-sentence core of any message — the one thing that must survive if everything else is lost. Use this skill whenever the user asks 'what's my one sentence?', 'simplify this pitch', 'find the core', 'one-liner for this', 'elevator pitch', 'boil this down', 'what's the headline?', 'TL;DR this', 'what's the one thing?', or has a draft, announcement, pitch, product description, speech, or strategy memo that says too many things at once. Also invoke when the user struggles with 'my message isn't landing', 'I have 30 seconds to explain this', 'we can't agree on messaging', 'nobody remembers our pitch', or wants a Commander's Intent, high-concept pitch, tagline, mission statement, or forced prioritization of candidate points. This is the foundation skill for all sticky messaging — run it BEFORE any unexpected/concrete/credible/emotional/story framing work.
Credibility Evidence Selector
Pick the strongest credibility evidence for a claim and kill weak evidence chains with the Sinatra Test. Use this skill whenever the user asks 'how do I prove this?', 'how do I make this more credible?', 'which statistic should I cite?', 'do I need a source for this?', 'how do I build trust?', 'this claim sounds unbelievable', 'they won't believe us', 'we need a case study', 'should I quote an expert?', 'is this testimonial strong enough?', 'which proof point should I lead with?', 'my pitch needs more evidence', 'the numbers aren't landing', 'how do I back this up without a credentials wall?', 'who should say this for maximum credibility?', or 'is one example enough or do I need data?'. Also invoke when the user has a marketing claim, sales pitch, fundraising ask, research finding, policy argument, product benefit, or security/reliability promise and must choose between authority quotes, customer stories, statistics, vivid details, testable demos, or a single hero example. This skill ranks evidence across six named credibility categories (external authority, antiauthority, testable credentials, vivid details, Sinatra Test hero example, statistics-as-illustration) and applies the Sinatra Test as a pass/fail filter to cut weak chains. Run BEFORE shipping any claim that a skeptical audience might doubt.
Curiosity Gap Architect
Build an Unexpected hook for a message, pitch, essay, ad, talk, or email — first break the audience's expected pattern to CAPTURE attention, then open a curiosity gap (a knowledge gap they didn't know existed) to HOLD attention all the way to the core message. Use this skill whenever the user says 'how do I hook them', 'what's my opening line', 'I need to get attention', 'this is boring how do I make it interesting', 'what's my angle', 'stop losing the audience', 'hook for my post', 'cold-open', 'lead paragraph', 'ad headline', 'landing page hero', 'intro for my talk', 'title that makes people click', 'my opening is flat', 'people tune out in the first 10 seconds', 'how do I make this dry topic interesting', 'email subject line', 'tweet hook', 'YouTube intro', 'TED-style opener', 'how Nora Ephron taught leads', 'Cialdini mystery opening', 'how to use surprise without being gimmicky'. Applies the two Unexpected mechanisms from Made to Stick Chapter 2: (1) SURPRISE via schema-break for short-term attention capture, (2) CURIOSITY GAP via Gap Theory of Curiosity (Loewenstein) for long-term attention hold. Every surprise option is scored against the POST-DICTABLE TEST — a good surprise feels inevitable in hindsight and drives home the core message; a gimmicky surprise gets a laugh but the audience can't remember the point. Produces 3 scored hook variants the user can drop into their draft. Does NOT rewrite the body of the message — only the hook and the gap structure. Does NOT manufacture shock or clickbait for its own sake. Relevant for: copywriters, marketers, product marketers, founders pitching, teachers, trainers, public speakers, content writers, journalists, fundraisers, PR, messaging, narrative design, persuasion, attention, Heath brothers, SUCCESs, Unexpected, Gap Theory, Loewenstein, schema break, postdictable, Ephron lead, Nordstrom Nordies, Cialdini Saturn rings, popcorn Silverman.
Curse Of Knowledge Detector
Diagnose a draft for the Curse of Knowledge — the expert blind spot that makes insiders write copy full of unexplained jargon, buried assumptions, strategy-level abstractions, and tacit shared context that lose non-expert audiences. Use this skill whenever reviewing a pitch, announcement, explainer, landing page, onboarding doc, slide, internal memo, or technical write-up for clarity to a non-expert. Activate when the user says things like "why isn't my message landing", "make this clearer", "my audience doesn't get it", "I can't tell if this is too technical", "diagnose this draft", "is this too jargony", "expert blind spot", "tapper listener", "translate for non-experts", "audit this for jargon", "I'm too close to this", or provides a draft plus an audience description and asks for a clarity critique. Also triggers when a user complains that smart readers stare blankly at their copy, when an explainer is full of acronyms, when an announcement leads with context instead of news, or when a strategy deck reads like a mission statement generator. This skill does NOT rewrite the draft end-to-end (that is the message-clinic skill) and does NOT score the full SUCCESs rubric (that is the stickiness-audit skill) — it produces a targeted report of Curse-of-Knowledge violations with locations, reasons, and rewrite guidance.
Emotional Appeal Selector
Choose the emotional lever that will make an audience actually care about a message — and strip out the analytical priming that kills charity before the emotional ask lands. Use this skill whenever a message is technically correct but emotionally flat, whenever the user asks "how do I make them care", "nobody cares about this", "why won't people act", "why should they care", "make this emotional without being cheesy", "motivate people", "this fundraising email isn't working", "rewrite this pitch so it lands", "our cause is important but donations are dropping", or "this announcement is dry and people are ignoring it". Also triggers when the user has a spreadsheet-heavy pitch, a statistics-first fundraising appeal, a recruiting message that lists benefits nobody responds to, a behavior-change campaign that's being ignored, a change-management memo that reads like a policy document, or a mission statement that employees cannot see themselves inside. Applies three named levers from Made to Stick — Association (tap emotions they already have), Self-Interest (what's in it for you, stated plainly), and Identity (who am I and what do people like me do) — plus the Mother Teresa / identifiable-victim rule (one specific person beats aggregate statistics) plus Maslow's eight needs used as a non-hierarchical palette (warning against "Maslow's basement" — assuming others are motivated only by money and security). Critically detects and removes analytical priming — calculations, spreadsheets, statistics placed before an emotional ask — because the mere act of calculation has been shown to reduce charitable response. This skill does NOT manipulate via fear, exploit vulnerability, or produce sympathy-begging copy. It does NOT write the full message end-to-end (pair with a rewriting skill); it produces an emotional-appeal plan — chosen lever, framing, concrete moves, and forbidden moves — that a writer or another skill can execute.
Message Clinic Runner
Run the full Made-to-Stick Idea Clinic on a draft message — diagnose it against SUCCESs, rewrite the weak dimensions, and ship a before/after pair with a one-sentence punch line explaining why the revision works. This is the end-to-end rework orchestrator for ONE draft at a time. Use this skill whenever the user says 'make this stickier', 'rewrite this message', 'improve this draft', 'run the clinic on this', 'full SUCCESs rework', 'before and after rewrite', 'fix this pitch', 'rework this announcement', 'this copy isn't landing — fix it', 'I need a sticky version of this', 'turn this into a kidney-heist version', 'make my announcement memorable', 'revise this fundraising email', 'rewrite this landing page hero', 'clinic this', 'do the Heath brothers treatment on this', 'rewrite end-to-end', or pastes a draft and asks for both a diagnosis AND a rewritten version. Also triggers when the user has already run a stickiness audit and now wants the rewrite executed, or when they hand over a draft plus audience plus goal and say 'just fix it.' Produces message-clinic-output.md containing SITUATION, MESSAGE 1 (original verbatim), DIAGNOSIS (routed through stickiness-audit), MESSAGE 2 (revised draft that preserves the user's tone and brand constraints), and a one-sentence PUNCH LINE explaining the key change and why it works. Delegates targeted fixes to foundation skills (core-message-extractor, curiosity-gap-architect, concrete-language-rewriter, credibility-evidence-selector, emotional-appeal-selector, story-plot-selector, curse-of-knowledge-detector) based on which dimensions scored weak. Preserves voice, brand, and legal constraints the user provides. Also handles the 'already sticky' case — if the draft passes the audit, returns a no-rework verdict with an explanation of why it already works rather than rewriting for the sake of rewriting. Does NOT process multi-message campaigns (one draft per invocation); does NOT replace stickiness-audit for diagnosis-only use; does NOT invent facts or testimonials the user has not supplied.
Stickiness Audit
Run the full SUCCESs stickiness audit on a draft message, pitch, announcement, slide, speech, landing page, or internal memo — the book's capstone diagnostic. Scores the draft across the six SUCCESs principles (Simple, Unexpected, Concrete, Credible, Emotional, Stories) plus the Curse of Knowledge villain axis on a 0/1/2 per-dimension scale (it is a checklist, not an equation), quoting evidence from the draft for every score and producing a top-3 prioritized fix list ranked by impact times effort. Use this skill whenever the user says things like "audit this message", "score this draft", "is this sticky", "run the SUCCESs check", "run the checklist", "will people remember this", "how good is this pitch", "rate this against Made to Stick", "does this pass the kidney heist test", "will this land", "stickiness review", "why is nobody remembering our launch", "I need a communications review", or when any user pastes a draft and asks whether it will resonate, be remembered, or change behavior. Also triggers when a user is about to ship a message and wants a last-mile quality gate, when someone asks for a one-page communications critique, or when a team is choosing between two draft versions and needs a principled scoring method. This skill produces a stickiness scorecard with dimension-level verdicts, evidence, prioritized fixes, and a recommendation for which specialist skill to invoke next (curse-of-knowledge-detector, core-message-extractor, curiosity-gap-architect, concrete-language-rewriter, credibility-evidence-selector, emotional-appeal-selector, story-plot-selector, or sticky-message-antipattern-detector). It does NOT perform the end-to-end rewrite — that is owned by the message-clinic workflow.
Sticky Message Antipattern Detector
Scan a draft, pitch, or copy for the named failure modes that kill stickiness — buried leads, decision paralysis, common-sense sedation, semantic stretch, stats-without-story, abstract strategy talk, scope creep, and the direct-message fallacy. Use this skill whenever a user asks to audit a draft, diagnose why a message is not landing, review a pitch, find the problems in copy, spot issues in an announcement, critique a marketing page, debug a speech, or check an internal memo — even when they do not explicitly use the word "stickiness". Activate on phrases like "audit this draft", "what is wrong with this message", "why is not this landing", "find the problems in this copy", "review my pitch", "spot the issues", "this is not resonating", "my announcement fell flat", "tell me what is broken in this email", "diagnose this speech", "why does not anyone remember what I said", "critique my copy", or any situation where the user supplies a short-form prose artifact and asks for a rigorous problem diagnosis rather than a rewrite. The skill produces a flagged-passage report with each instance located, severity-scored, and paired with a fix strategy — it does NOT rewrite the draft end-to-end and does NOT cover the Curse of Knowledge (that is a separate detector) or score the full six-principle SUCCESs rubric (that is a separate audit skill).
Story Plot Selector
Pick the right story plot (Challenge / Connection / Creativity) and structure it so it drives the specific action you need — and decide whether to deliver it as a springboard story or a direct argument. Use this skill whenever the user needs to find, pick, or shape a story, anecdote, or case study for a message, talk, pitch, announcement, training session, change effort, or culture push. Activate on "what story should I tell", "find me an anecdote", "how should I open this presentation", "we need a story here", "help me structure a case study", "which of these stories is the right one", "need an inspiring example", "tell a story about", "I have three anecdotes — pick one", "make this talk more human", "how do I open the all-hands", "what's the right case study for this pitch", "story for a keynote", "story to rally the team", "story for onboarding", "change management story", "need a motivating example", "story that shows why this matters", "the talk needs a narrative", or whenever a draft is pure argument/data and the user wants to replace or supplement a claim with a single concrete tale. Also triggers when the user has raw story material (news clipping, customer anecdote, personal experience, historical event) and asks how to frame or structure it. The skill classifies the story need into Challenge (overcoming obstacles — inspires perseverance), Connection (bridging differences — inspires empathy and cooperation), or Creativity (mental breakthrough — inspires experimentation), applies the matching structure, and decides between a springboard story (audience has agency, diverse contexts, you want buy-in) versus a direct argument (single unambiguous action). Also decides whether the story should work as simulation (mental rehearsal of how to act) or inspiration (motivation to act), or both. The skill does NOT fabricate events or invent characters — it works with real stories the user provides or helps them mine from real material. It does NOT write full emotional appeals (use emotional-appeal-selector) and does NOT score the full stickiness rubric (use stickiness-audit).
Evidence Based Training Designer
Redesign a corporate training program, employee training curriculum, employee onboarding, or in-service training so that learning actually sticks past the end of the session. Use this skill when a company's training is built on lecture-heavy workshops, single-topic day-long blocks, or passive e-learning modules that employees promptly forget; when an L&D team needs to convert a massed-practice curriculum into an evidence-based architecture; when a trainer or workshop design lead is building a new training program from scratch and wants to apply learning science from the start; when onboarding for a sales, technical, or certification role needs to produce durable competence rather than a test-passing event; when management asks why employees cannot apply training back on the job; when training program design needs to show measurable retention and transfer, not just satisfaction scores. This skill applies the corporate training models from Farmers Insurance (interleaved four-domain curriculum, FORE scaffolding, vision-poster goal anchoring, 5-4-3-2-1 sales system), Jiffy Lube (tell-show-do-review certification cycle, 80% threshold, biennial recertification), and Andersen Windows (2-hour job rotation, worker-led improvement, kaizen events) to redesign any training program. It does NOT design individual practice schedules for individual learners — use practice-schedule-designer for that.
Learning Practice Auditor
Audit any set of study habits, training program, or course design for ineffective learning practices and replace them with evidence-based alternatives. Use this skill when someone wants a study habits audit, suspects they are making learning mistakes, reports that their studying is not working, relies on rereading, highlighting, or cramming, wonders whether their training design actually produces learning, or asks "what am I doing wrong?" Also triggers on: ineffective studying complaints, rereading concerns, learning styles assumptions, cramming before an exam, blocked practice schedules, highlighting as primary review method, "I study for hours but nothing sticks," or any study strategy review. Works for individual learners, teachers, corporate trainers, instructional designers, and coaches. Detects five named anti-patterns — rereading trap, massed practice delusion, illusions of knowing cluster, learning styles myth, errorless learning myth — with mechanism explanations, severity ratings, and direct routing to the corrective skill. Do NOT use this skill to build a study schedule (use retrieval-practice-study-system), to design a practice sequence (use desirable-difficulty-classifier), or to calibrate mastery confidence (use learning-calibration-audit) — this skill diagnoses the problem and routes to those solutions.
Benefit Statement Drafter
Draft Benefit statements that link product capabilities to specific customer-expressed Explicit Needs. Use this skill when preparing follow-up emails, proposals, or demos after a discovery call, when someone asks 'how should I frame our solution for this customer?', 'draft Rackham-style benefits for my proposal', 'write the value section of my deck', 'the customer said X — what should I say back?', 'help me write benefits for this deal', 'turn our capabilities into benefits for this account', or 'I have a needs log — help me write the customer-facing statements'. This skill REFUSES to draft a Benefit when no matching Explicit Need exists in the customer record — it redirects to spin-discovery-question-planner instead. That refusal is not a flaw; it is the skill's core protection against the most common error in B2B sales: presenting capabilities before needs are confirmed. The output is a short, grounded set of draft statements (one per matched pair) that the user can adapt into a proposal section, a follow-up email, or a demo opening. Also applies the new-product-launch sub-flow: when the user is launching a new product and has no needs log yet, the skill shifts focus to problem identification and need development before drafting any Benefits — the approach that produced 54% higher sales in a controlled medical diagnostics experiment. Applies to B2B account executives, solutions consultants, and founder-led sellers preparing for follow-up conversations after discovery calls.
Call Outcome Classifier
Classify whether a sales call outcome was an Order, an Advance, a Continuation, or a No-sale — and flag when the seller has misread a Continuation as success. Use when someone asks "did this call go well?", "was this a successful call?", "classify this call outcome", "is this a Continuation or an Advance?", "the prospect said they were impressed but didn't commit to anything specific", "they said 'fantastic presentation, let's meet again' — is that progress?", "I'm not sure if we moved the deal forward", "how do I score this call?", or "the customer seemed positive but I don't know if we advanced." Also invoke when someone shares call notes or a transcript and wants to know whether the deal progressed, whether to update their CRM with a pipeline advance, or whether a next call is needed because this one stalled. Works on raw call notes, transcripts (Gong, Chorus, Zoom exports), or recalled summaries. Reads the call; identifies the specific customer action committed (or the absence of one); classifies the outcome against SPIN Selling's four-outcome framework; flags the classic Continuation-as-success misread; and outputs a written deal-tracking assessment. Pair with commitment-and-advance-planner (SPIN Selling) to plan a better Advance objective for the next call when this one ended in Continuation.
Closing Attitude Self Assessment
Administer and score the Closing-Attitude Scale — a 15-item validated psychometric from SPIN Selling research. Use when a salesperson wants to evaluate whether their attitude toward closing techniques fits the kind of sale they are running, assess whether they are closing too aggressively or too passively, diagnose if their pro-closing beliefs could be hurting their large-sale results, answer 'should I close harder?', 'am I closing too aggressively?', 'is my closing approach wrong for this type of deal?', or 'evaluate my closing attitude'. Also invoke for anyone who believes 'always be closing' is good sales practice, wants to test themselves against Rackham's research findings, or needs to understand why closing techniques hurt large-sale performance. The skill administers all 15 items interactively, calculates a total (15-75), interprets the score against the user's actual selling context (deal value, buyer sophistication, post-sale relationship), and delivers a written assessment with remediation guidance when score and context are mismatched.
Commitment And Advance Planner
Plan the specific commitment to target on a B2B sales call, and script how to obtain it without using closing pressure. Use this skill when someone asks "how do I close this deal", "what should I ask for at the end of the call?", "should I push for the close on Tuesday?", "how do I get this prospect to commit?", "what's a realistic next step to aim for?", "they keep saying they're interested but won't commit", "my manager wants me to close harder but I don't think that's working", "I need to plan my commitment strategy before tomorrow's call", "how do I avoid getting a non-answer at the end of the meeting?", "what's the difference between a real commitment and a polite brush-off?", "I keep getting Continuations instead of Advances", "how do I know what level of commitment to ask for?", or "what do I do when the prospect says 'let's stay in touch'?" Also invoke when someone is prepping for any major B2B sales call and wants a written plan for how to end it — even if they don't use the word "close" or "commitment." This skill produces a pre-call commitment plan with a primary Advance target, a fallback Advance, a Four Successful Actions script, and a Continuation guard. It explicitly replaces closing-technique training with Advance-targeting, grounded in empirical research showing that pressure closing reduces success rates in large sales. After the call, run spin-selling:call-outcome-classifier to verify whether the planned Advance was actually obtained.
Discovery Call Opening Planner
Plan a discovery call opening that earns the right to ask questions — without leading with product details or personal rapport fishing. Use this skill whenever a B2B rep is preparing for a sales call and needs to know what to say in the first 60-90 seconds, when someone asks 'how should I open this call?', 'what should I say first in my meeting with [company]?', 'how do I start a discovery call with a senior executive?', 'draft an opening for my call tomorrow', 'what's the best way to open a follow-up call?', or 'how do I avoid the awkward opener?'. This skill applies Rackham's empirically-validated framework for call openings in major sales: establish who you are, state why you're there (without product details), and earn the buyer's consent to ask questions. It explicitly prevents the two conventionally taught but research-debunked patterns: personal rapport fishing ('talk about the yacht photo on their wall') and opening benefit statements ('I'm here to show you how X saves you 30%'). Output is a call-prep script and checkpoint review the rep can read 5 minutes before the meeting. Invoke whenever any sales call opening needs to be planned, scripted, reviewed, or adapted to a specific call context.
Fab Statement Classifier
Classify seller statements as Features, Advantages, or true Benefits using Rackham's strict FAB definitions. Use this skill to audit a pitch deck, sales email, demo script, or call transcript for FAB distribution. Invoke when someone asks 'are these benefits or advantages?', 'is this a feature or a benefit?', 'review my sales deck for FAB', 'audit my pitch for Rackham FAB', 'classify these statements', 'are my slides benefit-focused?', 'why am I getting objections to my deck?', 'does this qualify as a benefit?', or 'I call these benefits but I'm not sure'. The skill enforces Rackham's empirically-derived definition: a statement is a Benefit ONLY if it meets a customer-expressed Explicit Need — not if it sounds helpful, not if it shows the product can help, and not if it meets a problem (Implied Need). In typical B2B sales content, 40-50% of statements labeled 'Benefits' by the seller are actually Advantages. This skill catches that. Also includes Rackham's 10-item FAB classification quiz for self-testing. Applies to B2B account executives auditing their own decks, sales managers reviewing team content, and marketers producing collateral for large-sale contexts.
Need Type Classifier
Classify customer statements from sales calls as Implied Needs (problems, difficulties, dissatisfactions) or Explicit Needs (wants, desires, intentions to act). Use this skill whenever a sales rep shares something a prospect said and asks what to do next, when reviewing call notes or transcripts to identify which customer statements represent buying signals, when diagnosing whether discovery went deep enough before a demo or proposal, when building a needs log from call notes, or when a colleague says 'the prospect sounded interested — they mentioned several problems.' This skill applies Rackham's empirically-validated SPIN methodology to prevent the most common large-sale mistake: treating Implied Needs (problems) as buying signals. In large B2B sales, Explicit Needs — not Implied Needs — predict deal success. Invoke whenever any customer statement needs to be categorized, developed, or acted on in a B2B or enterprise sales context.
Objection Source Diagnoser
Diagnose WHY a deal is accumulating objections by tracing each one back to its root-cause seller behavior. Use this skill when a customer keeps pushing back, when you're getting too many price objections, when the prospect raised concerns you don't know how to address, when a rep asks 'why does my pitch generate so much resistance?', or when someone asks 'what's wrong with my presentation?'. Invoke when someone says 'diagnose these objections', 'we keep getting price objections', 'why does the customer keep saying it's not worth it', 'how do I stop getting so many objections', 'the prospect raised X — how should I respond?', 'my deal has too many concerns', 'objections are killing my pipeline', or 'what's causing all this pushback?'. The skill reads call notes or transcripts, extracts every objection, and maps each to its FAB-source root cause using Rackham's empirically-derived behavior→response chain: Features cause price concerns; Advantages cause value and capability objections; premature solution presentation causes early-call objections. The output is a prevention plan for the NEXT call — which seller behaviors to remove, and which SPIN questions to use to develop needs more thoroughly. This skill explicitly refuses to produce 'when they say X, respond with Y' objection-handling scripts. That approach treats symptoms. This skill treats causes. Backed by Rackham's analysis of 35,000+ sales calls and Linda Marsh's correlation study showing Advantages as the primary driver of objections. Applies to B2B AEs, enterprise sales reps, and sales managers debriefing a struggling rep.
Sales Call Plan Do Review Coach
Wrap a structured Plan-Do-Review learning loop around any B2B sales call. Use this skill when someone says 'prep me for tomorrow's call with [company]', 'review my call from yesterday', 'help me debrief this meeting', 'what should I learn from this call?', 'build a call brief for next week', 'post-call debrief', 'I just had a discovery call and want to process it', or 'am I actually improving between calls?'. This skill runs in two modes: PRE-CALL — consolidates outputs from spin-discovery-question-planner (SPIN question bank) and commitment-and-advance-planner (Advance objective) into a single call brief you can read 5 minutes before the meeting; POST-CALL — applies Rackham's seven specific review questions to your actual call notes and produces a written debrief that ties directly to the next call's plan. The closed loop is the distinguishing feature: each call's review becomes the next call's plan. Based on Rackham's empirical finding that top performers review every call in detail while average performers say 'it went quite well' — a global conclusion that prevents any learning. Works on call notes, transcripts, or recalled summaries.
Spin Discovery Question Planner
Plan Situation, Problem, Implication, and Need-payoff (SPIN) questions for a specific B2B sales call. Use this skill whenever a sales rep wants to prepare discovery questions for an upcoming meeting, when someone asks 'what should I ask in this call?', when planning questions for a deal in any industry, when drafting Implication questions for a complex sale, when prepping for a discovery call with a prospect, when a seller wants to go into a meeting with a structured question bank instead of winging it, or when a rep has a call next week and needs help thinking through what to ask. This skill applies Rackham's empirically-validated SPIN methodology — specifically including the 3-step Implication question planning sub-workflow (problem → related difficulties → questions) that makes the hardest question type executable. The output is NOT a generic discovery checklist: it is a planned conversation with branches, Implication chains, and Need-payoff conversion moves tied to specific likely customer problems and product capabilities the seller can actually deliver.
Spin Skill Practice Coach
Build a personalized multi-week SPIN practice plan for a B2B sales rep learning the SPIN methodology. Use this skill when someone is new to SPIN and wants to build the skill systematically, when a rep says 'I read SPIN Selling but can't put it into practice', when someone asks 'how do I actually learn SPIN?', when a seller wants a structured practice curriculum, when a manager wants a rep to develop SPIN questioning skills without blowing key accounts, when someone asks 'how do I actually use Implication Questions in real calls?', when a rep is struggling to apply SPIN because it feels unnatural, when someone wants to build muscle memory for Problem or Need-payoff questions, or when a seller wants to know which accounts are safe to practice on. This skill applies Rackham's Four Golden Rules for skill learning — one behavior at a time, try it 3 times before judging, quantity before quality, safe situations first — plus a 4-step SPIN learning sequence, to build a personalized schedule calibrated to the user's current level and actual account portfolio. The output is a dated multi-week plan that names specific behaviors to practice in specific practice windows, not a feature list. A baseline LLM will produce tips ('read the book', 'practice in real calls', 'get feedback') — this skill produces a practice curriculum.
Auction Bidding Strategist
Apply the complete game-theoretic auction framework to determine the optimal bid in any auction format. Use this skill when a user is preparing to bid in an English (ascending) auction, a Japanese auction, a Vickrey (second-price sealed-bid) auction, a Dutch (descending-clock) auction, or a standard sealed-bid first-price auction, and wants the game-theoretically correct strategy rather than guesswork. Triggers include: user is deciding how much to bid in a competitive tender, procurement auction, real estate auction, eBay auction, spectrum license auction, or corporate acquisition; user is worried about overbidding and wants to know how to set a ceiling; user suspects they may be falling into the winner's curse — winning but regretting the price paid; user must classify whether the auction involves private values (each bidder's value is independent) or common values (the item has a single underlying value that all bidders are estimating), because the correct strategy differs sharply between the two; user is evaluating whether to participate in a dollar auction, bidding war, or war-of-attrition-style competitive spending contest and wants to know when to stop or avoid; user needs to shade a bid below their true value in a sealed-bid first-price format and wants the formula; user is designing an auction and wants to know which format will yield more seller revenue; user is bidding in multiple simultaneous auctions and needs to think across the games. This skill does NOT cover multi-round negotiation without a defined auction structure (use a negotiation skill instead), combinatorial auctions with complex package bids, or procurement auctions requiring cost estimation.
Backward Reasoning Game Solver
Solve sequential-move strategic games using backward induction. Use this skill when a user faces a multi-stage decision or negotiation where players alternate moves and each person's best action depends on what others will do later. Triggers include: user needs to determine the optimal opening move in a turn-based game or negotiation; user wants to know whether they can guarantee a win or favorable outcome before the game starts; user must sequence two risky actions and does not know which to attempt first; user is analyzing a multi-stage political, business, or competitive scenario where one party moves, the other responds, and so on; user has a finite-horizon sequential game with known player preferences and needs the game-theoretic solution; user suspects their opponent can anticipate their moves and wants to reason from end-states backward to their first action; user is building a game tree and needs to prune it to find dominant paths; user has a combinatorial takeaway game (like Nim variants) and wants the winning-position formula; user needs to understand why more flexibility or options can paradoxically hurt a player in a sequential game. This skill handles perfect-information, finite, sequential-move games. It does NOT cover simultaneous-move games (use a separate Nash equilibrium skill), incomplete-information games, or infinite-horizon repeated games.
Incentive Scheme Designer
Design and diagnose incentive contracts for situations where effort is unobservable (moral hazard). Use this skill when a user needs to motivate a contractor, employee, co-founder, or agent whose actions cannot be directly monitored; when a user is deciding between a fixed salary, piece-rate, equity share, bonus, or fine structure; when a user needs to set the bonus level so that high-quality effort is in the agent's self-interest; when a user must satisfy both the participation constraint (agent accepts the deal) and the incentive compatibility constraint (agent exerts the desired effort); when a user wants to diagnose why an existing incentive scheme is failing — through sandbagging, gaming, effort diversion, or lack of effort; when a user is deciding between carrots and sticks and needs to understand when each is preferred; when a user suspects financial incentives are crowding out intrinsic motivation (Gneezy/Rustichini effect); when a user manages people performing multiple tasks and needs to know whether to bundle or separate them based on complementarity vs. substitutability; when a user needs to understand efficiency wages and when above-market pay is the cheapest way to deter shirking. This skill covers the full principal-agent problem after a contract is signed. It does NOT cover pre-contract adverse selection (who to hire) — use the information-asymmetry-strategist skill for that.
Information Asymmetry Strategist
Diagnose and resolve information asymmetry in strategic interactions using four mechanisms: signaling, screening, signal jamming, and countersignaling. Use this skill when a user needs to credibly communicate private information to an uninformed counterpart; when a user needs to elicit honest information from a better-informed counterpart without being able to verify their claims; when a user suspects they are on the receiving end of signal jamming or adverse selection and wants to see through it; when a user is designing a pricing scheme, contract structure, hiring process, or product menu and needs to induce self-selection among different customer or candidate types; when a user wants to know whether to signal their quality, countersignal by staying silent, or jam an opponent's signals; when a user needs to apply Bayes' rule to update beliefs after observing an opponent's action in a mixed-strategy game; when a user faces Akerlof-style market collapse risk and wants to identify signaling or screening remedies; when a user is designing a menu of options (e.g., airline fare classes, insurance deductibles, product tiers) and needs to check participation constraints and incentive compatibility constraints. This skill handles both directions of information asymmetry: the informed party communicating outward (signaling, countersignaling, jamming) and the uninformed party extracting information inward (screening, adverse selection management). It does NOT cover moral hazard or principal-agent problems after a contract is signed, nor does it handle simultaneous-move games without information asymmetry (use the Nash equilibrium skill for those).
Nash Equilibrium Analyzer
Find Nash equilibria in simultaneous-move games by constructing payoff matrices, eliminating dominated strategies (Rules 2-3), mapping best responses (Rule 4), and calculating mixed strategy proportions using the indifference principle (Rule 5). Use this skill when two or more players choose actions simultaneously without seeing each other's moves — pricing decisions, product launches, competitive bids, penalty kicks, resource allocation conflicts — and you need to identify stable strategy configurations, calculate exact mixing proportions for zero-sum conflicts, or select among multiple equilibria using focal-point analysis.
Negotiation Strategist
Apply the complete game-theoretic bargaining framework to any negotiation. Use this skill when a user needs to structure a negotiation, determine who has leverage, calculate the fair split, or decide whether to make a concession or walk away. Triggers include: user is preparing for a salary negotiation, contract renegotiation, partnership deal, M&A term sheet, or labor negotiation and wants to know what number to open with and why; user wants to determine the 'pie' — the true surplus that is actually at stake between the two parties, not the headline dollar figures; user needs to identify and quantify their Best Alternative to a Negotiated Agreement (BATNA) or the other side's BATNA before entering talks; user wants to know how to improve their bargaining position before the negotiation starts (raise your BATNA, lower theirs); user must decide whether to bundle multiple issues together or separate them; user is weighing whether to actually strike, walk out, or threaten to do so, and wants to understand the cost-benefit calculation; user wants to propose a virtual-strike or escrowed-revenue arrangement to eliminate collateral damage while preserving negotiating pressure; user is in an alternating-offer negotiation and wants to calculate the equilibrium split given relative patience levels; user suspects they are negotiating over the wrong number (confusing total value with incremental value above no-deal); user faces brinkmanship — escalating risk of breakdown — and wants to calibrate how far to push. This skill does NOT cover simultaneous-move games (use nash-equilibrium-analyzer), one-shot ultimatum games without iteration, or multi-party coalition bargaining beyond two principal parties.
Prisoners Dilemma Resolver
Diagnose whether a multi-player conflict is a prisoners' dilemma and design a cooperation mechanism to resolve it. Use when parties are locked in a mutually destructive pattern even though all would benefit from cooperation — price wars, overfishing, arms races, advertising spirals, commons depletion, collective action failures. Distinguishes prisoners' dilemmas (dominant strategy to defect) from coordination problems (no incentive to deviate once aligned) and tailors the remedy accordingly. Produces a structured cooperation design plan: diagnosis, payoff assessment, discount-rate threshold calculation, mechanism selection from a resolution menu (self-enforcement through repeated play, tit-for-two-tats, mutual promises with escrow, linkage, reputation systems, third-party enforcement, Ostrom commons governance), and implementation checklist. Use when someone says 'everyone would be better off if we all cooperated but no one does', 'we keep undercutting each other even though it hurts everyone', 'how do we stop a race to the bottom', 'we need a collective agreement that actually holds', 'our cartel keeps collapsing', 'how do I stop a defection spiral', 'we need to solve a commons problem', or 'is this a coordination problem or a cooperation problem'.
Strategic Commitment Designer
Design credible strategic moves — commitments, threats, and promises — to change the game in your favor before play begins. Use this skill when a user needs to lock in a position and prevent backtracking; deter an adversary from an unwanted action; compel a counterpart to take a desired action; make a negotiation stance, policy, or business pledge actually believable; or structure incentive mechanisms that hold even when renegotiation is tempting. Triggers include: user wants to commit to a course of action in a way that others will believe; user is setting a credible deterrent threat (e.g., retaliation policy, penalty clause, price floor); user must compel action by a deadline and needs the right move type and deadline design; user suspects their threat or promise will be dismissed as a bluff; user needs to choose between issuing a threat vs. a promise for deterrence or compellence; user wants to practice brinkmanship and needs to calibrate the risk level; user is designing a contract or commitment mechanism and needs to close renegotiation loopholes; user is countering an opponent's commitment or threat. This skill covers the full taxonomy of strategic moves (commitment / threat / promise, deterrence / compellence, warnings / assurances) and all eight credibility mechanisms. It does NOT perform the underlying game tree analysis — use backward-reasoning-game-solver for that before applying this skill.
Strategic Situation Analyzer
Classify any strategic situation and route to the right game-theory skill. Use this skill whenever a user describes any situation involving multiple decision-makers whose outcomes depend on each other's choices. Triggers include: user says 'I'm not sure how to think about this strategically'; user faces a competitive or cooperative decision and doesn't know where to start; user asks which game theory concept applies to their situation; user describes a negotiation, competition, auction, vote, or incentive design problem and wants to know the right framework; user asks 'is this a prisoners' dilemma?'; user wants to understand whether their situation calls for cooperation or competition; user has a business, political, or personal strategic dilemma and needs a diagnostic before diving into analysis; user says 'what kind of game am I playing?'; user describes any interaction where their best action depends on what others will do; user is unsure whether to look for dominant strategies, equilibria, or use backward reasoning; user needs to decide whether to move first or second; user wonders whether they should cooperate, compete, randomize, commit, signal, or negotiate. This is the ENTRY POINT skill for the entire Art of Strategy skill set. It diagnoses the game type and routes to the specialized skill best suited to the situation. It does NOT replace the specialized skills — it prepares the user to use them effectively.
Voting System Strategist
Analyze, design, or defend against voting system manipulation. Use this skill when a user needs to evaluate how a voting or election procedure will behave strategically — including which candidate or option will actually win under a given system, how an agenda-setter can engineer an outcome, whether a preference cycle makes the 'true will' of the group unknowable, how to choose the voting rule best suited to a group's goals, or when a voter should vote strategically rather than sincerely. Triggers include: user is designing a committee, board, or organizational voting process and wants to know which system is fairest or hardest to manipulate; user suspects the order of votes or the choice of voting method is being used against them; user needs to predict who wins under plurality, runoff, Condorcet pairwise, Borda count, or approval voting; user wants to know whether their group's preferences form a cycle that makes any outcome unstable; user is a voter or participant wondering whether to vote sincerely or strategically; user is analyzing a legislative, judicial, or board vote where agenda control may be shaping the outcome; user needs to apply the median voter theorem to predict where competing positions will converge; user wants to evaluate the pivotal-voter principle to understand when a single vote actually changes outcomes. This skill covers social choice theory, Arrow's impossibility theorem, the Condorcet paradox, agenda control via sequential voting, strategic (insincere) voting, comparison of voting rules, the median voter theorem, approval voting, and pivotal voter analysis. It does NOT cover simultaneous-move strategic games (use nash-equilibrium-analyzer), sequential multi-player negotiation (use other negotiation skills), or auction design.
Author Commercial Teaching Pitch
Author a Commercial Teaching pitch using the six-step choreography and polish it with SAFE-BOLD. Trigger this skill when you need to: - Write a sales pitch using commercial teaching methodology - Build a commercial teaching pitch from a validated insight - Structure a six-step pitch: warmer reframe rational drowning emotional impact new way solution - Author a sales narrative that leads to your solution rather than leading with it - Build a sales deck following challenger selling choreography - Write a challenger pitch or insight-led pitch for a B2B conversation - Draft a pitch script for a sales rep or sales enablement team - Differentiate a sales conversation by teaching customers something new about their business - Apply SAFE-BOLD to sharpen a teaching pitch before delivery NOT for: building the commercial insight itself (use build-commercial-insight first), tailoring the pitch to individual stakeholders (use tailor-pitch-by-stakeholder after), or diagnosing an existing pitch (use diagnose-pitch-for-commercial-teaching-fit).
Build Commercial Insight
Reverse-engineer a Commercial Insight from seller strengths and validate it against the four-criteria test. Trigger this skill when you need to: - Build a commercial insight or reframe for a teaching pitch - Figure out "what insight should I teach" in a B2B sales conversation - Find a unique angle for a commercial teaching pitch - Reverse engineer a pitch from your strengths (the "Deb Oler question") - Identify which insight to lead with in an insight-led selling approach - Differentiate your pitch from competitors who sell the same category - Determine whether a proposed reframe qualifies as commercial teaching - Start a sales narrative from your solution's unique differentiator rather than customer pain - Create an insight that "leads to" your strengths rather than "leading with" them NOT for: building the full 6-step pitch choreography (use author-commercial-teaching-pitch), tailoring to specific stakeholders (use tailor-pitch-by-stakeholder), or scoring pitch boldness (use SAFE-BOLD framework).
Classify Rep Profile
Classify a sales rep against the five CEB selling profiles (Challenger, Hard Worker, Relationship Builder, Lone Wolf, Reactive Problem Solver) and score their Teach/Tailor/Take-Control subscales using the Appendix B self-diagnostic. Use when a rep wants to know 'am I a Challenger', 'which sales profile am I', 'sales style assessment', 'classify sales rep', 'Challenger profile quiz', 'CEB sales profile', 'Teach Tailor Take Control self-diagnostic', 'what kind of rep am I', 'Relationship Builder Hard Worker Lone Wolf Reactive Problem Solver assessment', 'B2B sales rep diagnostic', 'rep profile classification', 'sales enablement assessment'. Applies CEB's empirical study of 6,000+ reps and 44 behavioral attributes. Produces a rep-profile-assessment.md artifact with profile classification, three subscale scores, threshold interpretation, dominant profile flags, and prioritized development recommendations.
Coach Rep With Pause Framework
Plan a structured coaching session for a sales rep using the PAUSE framework (Prepare → Affirm → Understand → Specify → Embed). Use when a manager needs to: run a 'sales coaching session', 'coach a sales rep', use 'PAUSE coaching', ask 'pre-call coaching questions', run a 'post-call debrief', do 'challenger rep coaching', follow a 'sales manager coaching guide', 'coach the rep not the deal', answer 'how to coach my rep', or build a '1:1 coaching agenda'. Reads rep-profile-assessment.md from classify-rep-profile to identify the rep's weakest Challenger pillar, selects the Appendix A question set for that pillar, and produces a coaching-session-plan.md with pre-call questions, observation focus, post-call debrief, and an embed homework assignment. Also includes a decision gate: if the issue is deal-specific (stalled deal, unknown obstacle) rather than a rep-behavior gap, routes to the sales innovation mode (Investigate → Create → Share + optional SCAMMPERR) instead of PAUSE coaching.
Diagnose Manager Effectiveness
Diagnose a frontline sales manager's effectiveness against the CEB four-driver model. Use when someone asks: 'sales manager effectiveness', 'am I coaching the right reps', 'sales manager diagnostic', 'manager coaching ROI', 'where should I spend coaching time', 'sales manager assessment', 'Challenger sales manager', 'manager drivers', 'front-line manager performance', 'am I a good sales manager', 'sales manager self-assessment', 'coaching time allocation', 'am I spending coaching time correctly', 'democratic coaching', 'why is my team not improving'. Produces a manager-effectiveness-diagnosis.md with weighted driver scores, active anti-patterns, and a concrete time-reallocation plan based on team composition.
Diagnose Pitch For Commercial Teaching Fit
Audit an existing sales pitch, deck, or call transcript against the Commercial Teaching rubric. Use this skill when you want to review your deck, diagnose why your pitch isn't working, check whether your pitch leads with solution instead of leading to it, run a commercial teaching check, get a pitch diagnostic, run a sales deck review, figure out why your pitch isn't differentiating, or check whether your pitch opens with your solution before establishing a customer problem. Detects lead-with-vs-lead-to errors, missing Reframes, Rational Drowning misfocus, teaching-into-the-desert traps, buzzword pollution, and sequence violations. Produces a scored per-step rubric with highlighted problem passages and rewrite recommendations.
Diagnose Taking Control Gaps
Diagnose a deal's taking-control posture: foil-RFP detection, passive/assertive/aggressive positioning, and misconception analysis. Trigger this skill when you need to: - Diagnose a stalled deal to find out why it isn't moving - Determine whether you're in a foil RFP (a verification exercise, not a real opportunity) - Assess whether a rep is too passive, appropriately assertive, or crossing into aggressive territory - Identify misconceptions about "taking control" that are limiting a rep's deal behavior - Understand why you're losing control of the sale or the customer conversation - Apply constructive tension without becoming combative - Evaluate whether a customer is verifying price with a competitor already chosen - Unblock a stalled pipeline deal by diagnosing the control gap - Coach a rep who is too passive or who conflates assertiveness with aggressiveness - Determine whether a rep is helping the customer navigate their own buying process (Lead and Simplify) NOT for: full negotiation planning — concession sequencing, the DuPont four-step negotiation roadmap, SSN pre-call templates (use plan-negotiation-with-constructive-tension for those).
Plan Challenger Model Rollout
Plan a full Challenger model rollout for a sales organization. Use when someone asks: 'implement Challenger model', 'roll out new sales methodology', 'sales transformation plan', 'change management sales', 'pilot Challenger', 'sales methodology adoption', 'implementation roadmap', 'enablement plan', 'sales training rollout', 'sales change management', 'how do I roll out Challenger', 'Challenger implementation plan', 'sales force transformation', 'how to scale Challenger across the team'. Applies Grainger's four-question pilot framework, star/core/laggard adoption sequencing, 80% adoption target, 20–30% attrition planning, and a four-track parallel workstream design (training, tools, coaching, manager enablement). Produces a rollout-plan.md with pilot scope, adoption sequence, 12-month milestone schedule, and attrition/backfill plan.
Plan Negotiation With Constructive Tension
Build a pre-call negotiation plan using DuPont's four-step framework and sequence concessions to avoid the proactive-discount and ultimatum traps. Trigger this skill when you need to: - Plan a negotiation for a B2B sales deal before a pricing or concession conversation - Respond to a customer discount request without immediately caving on price - Counter a price reduction demand by broadening the negotiation beyond price - Structure your concession sequence so you trade low-value items first and protect margin - Avoid proactive discounting, escalating concession patterns, or ultimatum traps - Apply the DuPont four-step negotiation framework (Acknowledge & Defer → Deepen & Broaden → Explore & Compare → Concede According to Plan) - Use the Situational Sales Negotiation (SSN) pre-call planning template to score concessions before the call - Build scripted deferral language to buy time without threatening the deal - Prepare for a challenger negotiation with constructive tension - Draft a pre-call negotiation worksheet for an upcoming customer conversation NOT for: diagnosing whether you have a taking-control problem in the first place — run diagnose-taking-control-gaps first to produce the control diagnosis this skill consumes.
Tailor Pitch By Stakeholder
Tailor a Commercial Teaching pitch to each stakeholder role using Functional Bias Cards and route the pitch to avoid the C-suite elevation trap. Trigger this skill when you need to: - Tailor a sales pitch to different roles in a buying committee - Build stakeholder-specific messaging for a multi-stakeholder sale - Create a different message for VP Engineering vs CFO vs procurement - Use a Functional Bias Card to map what each role cares about - Build a stakeholder map for an enterprise deal - Understand who to pitch to first and in what order - Adapt a pitch for different audience roles without losing the core insight - Tailor for resonance with a buying committee - Create per-role pitch variants from a single base pitch script - Build consensus across a buying group before reaching the decision-maker NOT for: building the base pitch (use author-commercial-teaching-pitch first), building the underlying commercial insight (use build-commercial-insight), or diagnosing an existing pitch's structure (use diagnose-pitch-for-commercial-teaching-fit).
Bullseye Channel Selection
Guide systematic customer acquisition channel selection using the Bullseye Framework. Use whenever a startup founder, growth marketer, or product leader is deciding which marketing channel to focus on, evaluating customer acquisition options, choosing between viral, SEO, SEM, content, sales, PR, or any other growth channel, struggling with where to invest marketing budget, trying to escape channel bias, asking 'how do we get customers', planning a go-to-market, or needs to narrow 19 possible channels down to one focused bet. Activates on phrases like 'channel selection', 'customer acquisition', 'marketing strategy', 'growth channel', 'traction channel', 'Bullseye Framework', 'which channel should we use', 'how do we grow', 'marketing plan', or any discussion of prioritizing acquisition investments.
Business Development Pipeline
Build a business development pipeline with 5 partnership types, attribute-based partner selection, and a 9-step BD process. Use whenever a founder or BD lead is planning partnerships, pursuing integration deals, negotiating licensing, structuring joint ventures, setting up distribution deals, sourcing supply partnerships, or transitioning from traditional BD to low-touch self-serve BD. Activates on phrases like 'business development', 'BD', 'partnerships', 'strategic partner', 'integration partner', 'licensing deal', 'distribution partner', 'joint venture', 'channel partner', 'co-marketing', 'white label', 'BD deal'.
Content And Email Marketing
Design content marketing and email lifecycle programs that work together as an acquisition engine. Use whenever a founder or marketer is planning a blog, newsletter, content calendar, email sequences, lead magnets, drip campaigns, onboarding emails, activation emails, retention emails, or any combination of content creation and email marketing. Also covers the acquisition → activation → retention → revenue lifecycle. Activates on phrases like 'content marketing', 'blog strategy', 'newsletter', 'email marketing', 'drip campaign', 'onboarding emails', 'lifecycle emails', 'activation email', 'email list', 'lead magnet', 'nurture sequence', 'email automation'.
Engineering As Marketing
Design free tools and micro-sites that acquire customers through engineering effort rather than ad spend. Use whenever a founder or marketer wants to build a free calculator, tool, widget, grader, or educational resource as a customer acquisition channel. Activates on phrases like 'engineering as marketing', 'free tool', 'marketing tool', 'calculator', 'grader', 'micro-site', 'widget', 'free app', 'HubSpot Marketing Grader', 'Moz tools', 'lead generator tool', 'utility for marketing', 'free resource for customers'.
Existing Platform Leverage
Leverage existing platforms with large user bases (App Stores, browser extensions, social networks, super-platforms) for startup customer acquisition via parasitic growth patterns. Use whenever a founder is planning to distribute via app stores, building browser extensions, targeting Facebook or Twitter as a channel, launching on a new platform Day-1, exploiting an unsatisfied need on a larger platform, or mapping platform gap opportunities. Activates on phrases like 'App Store strategy', 'Chrome extension', 'browser extension', 'Facebook platform', 'Apple ecosystem', 'existing platforms', 'distribution platform', 'Product Hunt launch', 'Airbnb Craigslist', 'YouTube MySpace', 'Zynga Facebook', 'parasitic growth'.
Sem Performance Optimization
Optimize Search Engine Marketing performance using CTR, CPC, CPA formulas, Quality Score benchmarks, and keyword profitability filtering. Use whenever a founder or marketer is running Google Ads, Bing Ads, or any SEM campaign, measuring CAC on paid search, optimizing ad groups, pruning unprofitable keywords, improving Quality Score, testing SEM as a channel, or comparing SEM vs other acquisition channels. Activates on phrases like 'SEM', 'Google Ads', 'AdWords', 'PPC', 'pay-per-click', 'CPC', 'CPA', 'CTR', 'Quality Score', 'keyword optimization', 'paid search', 'ad groups', 'bid strategy', 'search advertising'.
Seo Channel Strategy
Select and execute an SEO strategy using the fat-head vs long-tail binary decision framework. Use whenever a founder or marketer is planning SEO, comparing organic search strategies, choosing between targeting high-volume category keywords or many low-volume long-tail terms, evaluating keyword difficulty, planning content production for SEO, or avoiding black-hat tactics. Activates on phrases like 'SEO strategy', 'SEO', 'search engine optimization', 'organic search', 'ranking on Google', 'keyword research', 'fat-head', 'long-tail', 'content for SEO', 'Moz', 'keyword difficulty', 'link building', 'SERP', 'backlinks'.
Startup Critical Path Planning
Guide a startup to set a single quantified traction goal and define the critical path of milestones to reach it. Use whenever a founder needs to prioritize activities, set growth goals, define milestones, decide what NOT to work on, plan quarterly/yearly execution, cascade goals to teams, escape the 'too many things to do' trap, or apply a binary on-path/off-path filter to proposed work. Activates on phrases like 'traction goal', 'critical path', 'what should we focus on', 'too many priorities', 'prioritization', 'milestones', 'quarterly planning', 'yearly goals', 'OKRs', 'where should I spend my time', 'what NOT to do', 'company planning', 'goal setting', 'DuckDuckGo', 'roadmap'.
Startup Pr Outreach
Guide startup PR and unconventional PR outreach using the media chain, pitch templates, and amplification tactics. Use whenever a founder or marketer needs to pitch reporters, plan a PR campaign, land media coverage, run a publicity stunt, amplify a press story, use HARO, build reporter relationships, or avoid common PR mistakes. Also covers unconventional PR (stunts, customer appreciation) for startup launches. Activates on phrases like 'press release', 'PR campaign', 'media coverage', 'reporter outreach', 'pitch email', 'TechCrunch', 'HARO', 'product launch', 'PR strategy', 'publicity stunt', 'get coverage', 'press pitch', 'media pitch', 'journalist outreach'.
Startup Sales Process
Design startup sales processes using SPIN Selling, A/B/C lead tiering, PNAME qualification, and sales funnel design. Use whenever a founder or sales lead is building a sales process, prioritizing leads, qualifying prospects, structuring sales calls, designing a sales funnel, dealing with enterprise deals, avoiding the Technology Tourist or False Change Agent traps, or transitioning from founder-led sales to a scaled sales team. Activates on phrases like 'sales process', 'sales funnel', 'SPIN selling', 'lead qualification', 'BANT', 'PNAME', 'enterprise sales', 'B2B sales', 'sales call structure', 'closing deals', 'pipeline management', 'sales methodology'.
Startup Traction Strategy By Phase
Guide startup growth strategy by diagnosing which phase the startup is in (Phase I: making something people want, Phase II: marketing something people want, Phase III: scaling) and selecting phase-appropriate traction channels. Use whenever a startup founder, growth marketer, or product leader is deciding how to split time between product and traction, asking whether they have product-market fit, choosing which channels fit their current stage, dealing with rising CAC or saturating channels, wondering if they should pivot, applying the 50% Rule, or escaping the Product Trap ('if we build it they will come'). Activates on phrases like 'product-market fit', 'phase I', 'phase II', 'scaling', 'growth strategy', 'should we pivot', '50% rule', 'product trap', 'traction vs product', 'which channels for our stage', 'moving the needle'.
Traction Channel Testing
Design and run cheap validation tests for customer acquisition channels before committing budget. Use whenever a startup founder, growth marketer, or product leader needs to test a marketing channel, validate CAC and LTV assumptions, set up A/B testing, calculate whether a channel can hit growth targets, measure channel performance, detect a saturating channel (Law of Shitty Click-Throughs), decide whether to optimize or abandon a channel, or compare channels quantitatively. Activates on phrases like 'test a channel', 'cheap test', 'CAC', 'customer acquisition cost', 'LTV', 'lifetime value', 'A/B test', 'does this channel work', 'how do I know if this is working', 'conversion rate', 'channel metrics', 'measure marketing', 'channel saturation', 'Law of Shitty Click-Throughs'.
Viral Growth Loop Design
Design and measure viral growth loops using the viral coefficient (K-factor), viral loop type taxonomy, and cycle time optimization. Use whenever a startup founder, growth marketer, or product lead is designing referral programs, measuring word-of-mouth, building viral features, calculating K-factor, trying to achieve exponential growth, optimizing invite flows, debugging a viral feature that isn't working, or evaluating whether viral is the right channel. Activates on phrases like 'viral marketing', 'viral coefficient', 'K-factor', 'referral program', 'invite flow', 'network effects', 'word of mouth', 'exponential growth', 'viral loop', 'Dropbox referral', 'Hotmail signature', 'inherent virality', 'cycle time', 'should we go viral'.
Access Control Vulnerability Testing
Systematically test web application access controls for broken authorization vulnerabilities. Use this skill whenever: performing a penetration test or security assessment of a web application's authorization model; testing for vertical privilege escalation (low-privilege user accessing high-privilege functions); testing for horizontal privilege escalation (user accessing another user's data); auditing multistage workflows for mid-flow authorization bypasses; checking whether protected static files are directly accessible without authorization; testing whether HTTP method substitution (HEAD, arbitrary verbs) bypasses platform-level access rules; probing for insecure access control models based on client-submitted parameters (admin=true), HTTP Referer headers, or IP geolocation; enumerating hidden or unlisted application functionality; reviewing source code or HTTP traffic for missing server-side authorization checks; using Burp Suite's site map comparison feature to compare high-privilege and low-privilege user access; assessing server-side API endpoint authorization. Covers all six WAHH vulnerability categories: completely unprotected functionality, identifier-based access control (IDOR), multistage function bypasses, static file exposure, platform misconfiguration, and insecure client-controlled access models. Maps to OWASP Testing Guide (OTG-AUTHZ-*), CWE-284 (Improper Access Control), CWE-285 (Improper Authorization), CWE-639 (Authorization Bypass Through User-Controlled Key), CWE-862 (Missing Authorization), CWE-863 (Incorrect Authorization), and OWASP Top 10 A01:2021 (Broken Access Control).
Application Logic Flaw Testing
Test web application business logic for vulnerabilities that automated scanners cannot detect. Use this skill when: performing a penetration test or security assessment and automated tools have been run but logic-layer coverage is still needed; testing multistage workflows (checkout, account creation, approval flows, insurance applications) for stage-skipping or cross-stage parameter pollution; probing authentication and password-change functions for parameter-removal bypasses (deleting existingPassword to impersonate an admin); testing numeric business limits for negative-number bypass (submitting -$20,000 to avoid approval thresholds); probing discount or pricing logic for timing flaws (add items to qualify, remove before payment); investigating whether shared code components allow session object poisoning across unrelated application flows; hunting for encryption oracles where a low-value crypto context can be used to forge high-value tokens; probing search functions that return match counts as side-channel inference oracles; testing for defense interaction flaws where quote-doubling plus length truncation reconstructs an injection payload; checking whether debug error messages expose session tokens or credentials cross-user via static storage; testing race conditions in authentication that cause cross-user session assignment under concurrent login. Logic flaws arise from violated developer assumptions — assumptions that users will follow intended sequences, supply only requested parameters, omit parameters they were not asked for, and not cross-pollinate state between application flows. Each flaw is unique and application-specific, but the 12 attack patterns documented here provide a reusable taxonomy that transfers across application domains. Maps to OWASP Testing Guide (OTG-BUSLOGIC-*), CWE-840 (Business Logic Errors), CWE-841 (Improper Enforcement of Behavioral Workflow), CWE-362 (Race Condition), and OWASP Top 10 A04:2021 (Insecure Design).
Authentication Security Assessment
Systematically assess web application authentication mechanisms for design flaws and implementation vulnerabilities. Use this skill whenever: testing the login security of a web application; auditing authentication for unauthorized access risk; evaluating password policy strength or brute-force resistance; checking whether login failure messages leak usernames (user enumeration); testing credential transmission over HTTP vs HTTPS; reviewing password change or forgotten password flows for logic flaws; assessing "remember me" cookie security; testing multistage login mechanisms for stage-skipping or cross-stage credential mixing; reviewing source code or HTTP traffic for fail-open logic or insecure credential storage; performing a penetration test or security code review of any user authentication system. Covers HTML forms-based, HTTP Basic/Digest, and multifactor authentication. Maps to OWASP Testing Guide (OTG-AUTHN-*) and CWE-287 (Improper Authentication), CWE-521 (Weak Password Requirements), CWE-307 (Improper Restriction of Excessive Authentication Attempts), CWE-640 (Weak Password Recovery Mechanism), CWE-312 (Cleartext Storage of Sensitive Information), CWE-522 (Insufficiently Protected Credentials).
Client Side Attack Testing
Test web applications for client-side security vulnerabilities spanning two major attack families: client-side trust anti-patterns and user-targeting attacks. Use this skill when: auditing hidden form fields, HTTP cookies, URL parameters, Referer headers, or ASP.NET ViewState for client-side data transmission vulnerabilities; bypassing HTML maxlength limits, JavaScript validation, or disabled form elements to probe server-side enforcement gaps; intercepting and analyzing browser extension traffic (Java applets, Flash, Silverlight) and handling serialized data; testing for cross-site request forgery (CSRF) by identifying cookie-only session tracking and constructing auto-submitting PoC forms; testing for clickjacking and UI redress attacks by checking X-Frame-Options headers and constructing iframe overlay proofs of concept; detecting cross-domain data capture vectors via HTML injection and CSS injection; auditing Flash crossdomain.xml and HTML5 CORS Access-Control-Allow-Origin configurations for overly permissive same-origin policy exceptions; finding HTTP header injection and response splitting vulnerabilities via CRLF injection; identifying open redirection vulnerabilities and testing filter bypass payloads; testing cookie injection and session fixation; assessing local privacy exposure through persistent cookies, cached content lacking no-cache directives, autocomplete on sensitive fields, and HTML5 local storage. Excludes XSS (covered by xss-detection-and-exploitation). Maps to OWASP Testing Guide (OTG-INPVAL-*, OTG-SESS-*, OTG-CLIENT-*), CWE-352 (CSRF), CWE-601 (Open Redirect), CWE-113 (HTTP Header Injection), CWE-565 (Reliance on Cookies), CWE-1021 (Improper Restriction of Rendered UI Layers), CWE-311 (Missing Encryption of Sensitive Data), and OWASP Top 10 A01:2021, A03:2021, A05:2021.
Server Side Injection Testing
Test web application back-end components for non-SQL server-side injection vulnerabilities. Use this skill when: testing for OS command injection via shell metacharacters (pipe, ampersand, semicolon, backtick) or dynamic execution functions (eval/exec/Execute); detecting blind command injection using time-delay technique (ping -i 30 loopback) when output is not reflected; probing for path traversal vulnerabilities including filter bypass via URL encoding, double encoding, 16-bit Unicode, overlong UTF-8, null byte injection, or non-recursive strip bypass; testing for Local File Inclusion or Remote File Inclusion; identifying XML External Entity (XXE) injection for local file read or Server-Side Request Forgery (SSRF); detecting SOAP injection via XML metacharacter probing; testing for HTTP Parameter Injection (HPI) and HTTP Parameter Pollution (HPP) in back-end HTTP requests; identifying SMTP injection through email header manipulation or SMTP command injection in mail submission forms. Covers detection procedures, filter bypass techniques, exploitation impact, and prevention countermeasures. Maps to CWE-78 (OS Command Injection), CWE-22 (Path Traversal), CWE-98 (File Inclusion), CWE-611 (XXE), CWE-91 (XML Injection), CWE-88 (Argument Injection), CWE-93 (SMTP Injection). For authorized security testing, security code review, and defensive hardening contexts.
Session Management Security Assessment
Systematically assess web application session management for security vulnerabilities. Use when testing session token generation quality, cookie security configuration, session fixation susceptibility, cross-site request forgery (CSRF) exposure, or session token handling across a session's full lifecycle. Covers the complete taxonomy of generation weaknesses (meaningful tokens with user data embedded, predictable tokens from concealed sequences or time-dependent algorithms or weak pseudorandom number generators, encrypted tokens vulnerable to ECB block rearrangement or CBC bit-flipping) and handling weaknesses (cleartext transmission, token disclosure in server logs or URLs, vulnerable token-to-session mapping, ineffective logout and expiration, client-side hijacking exposure, overly liberal cookie domain or path scope). Use when someone says 'test our session tokens', 'analyze cookie security', 'check for session fixation', 'verify CSRF protection', 'assess token predictability', 'evaluate our session management', 'can session tokens be guessed', 'review logout implementation', 'check cookie flags', or 'audit session security'. Produces a structured vulnerability report with per-weakness findings and remediation guidance. Framed for authorized security testing, defensive security assessment, and educational contexts.
Source Code Security Review
Perform a systematic white-box security review of web application source code to find exploitable vulnerabilities. Use this skill when: you have authorized access to an application's source code and need to identify security flaws faster or more thoroughly than black-box testing alone; auditing a codebase prior to launch or after a security incident; reviewing open-source or purchased software for embedded vulnerabilities; complementing an active penetration test with source-level analysis. Applies a three-phase methodology: (1) identify all user-input entry points via platform-specific source APIs — Java HttpServletRequest, ASP.NET Request.Params/Form/QueryString, PHP $_GET/$_POST/$_COOKIE/$_REQUEST, Perl CGI param(), JavaScript document.location/URL; (2) trace data flow forward to dangerous sink APIs — Runtime.exec()/Process.Start() for OS command injection, Statement.execute()/mysql_query() for SQL injection, FileInputStream/include() for path traversal, sendRedirect()/header() for open redirect, eval() for script injection; (3) line-by-line close review of authentication, session management, access control, and native code components. Covers 8 vulnerability signature categories: cross-site scripting, SQL injection, path traversal, arbitrary redirection, OS command injection, backdoor passwords, native software bugs (buffer overflow, integer flaw, format string), and incriminating source code comments. Also covers database code components (stored procedures with dynamic SQL) and environment configuration checks (web.xml, Web.config, php.ini). Produces a prioritized findings report with evidence and countermeasures. Maps to CWE-79 (XSS), CWE-89 (SQL Injection), CWE-22 (Path Traversal), CWE-601 (Open Redirect), CWE-78 (OS Command Injection), CWE-798 (Hardcoded Credentials), CWE-120/121/122 (Buffer Overflow), CWE-134 (Format String). For authorized security review engagements, appsec engineers, and security-minded developers.
Sql Injection Detection And Exploitation
Perform a complete SQL injection assessment chain — from initial detection through full data extraction — against web applications. Use this skill whenever: testing any URL parameter, POST body field, cookie, or HTTP header for SQL injection susceptibility; auditing source code for unsafe query construction; reviewing whether parameterized queries or stored procedures are correctly applied; walking through the full UNION-based data extraction procedure against a vulnerable endpoint; applying blind SQL injection (boolean-based or time-based) when query results are not reflected; determining which database platform (MS-SQL, MySQL, Oracle, PostgreSQL) is running and adapting payloads accordingly; bypassing input filters using case variation, comment injection, encoding, or nested-expression techniques; identifying second-order SQL injection where stored data is later used unsafely in a query; assessing whether SQL injection can escalate to OS command execution via xp_cmdshell, UTL_HTTP, or SELECT INTO OUTFILE; testing NoSQL, XPath, or LDAP injection as related interpreted-language injection classes; performing a penetration test or secure code review of any application data-access layer. Maps to OWASP Testing Guide (OTG-INPVAL-005), CWE-89 (SQL Injection), CWE-564 (SQL Injection via Stored Procedure), CWE-943 (Improper Neutralization of Special Elements in Data Query Logic).
Web Application Attack Surface Mapping
Systematically map a web application's content, entry points, technologies, and attack surface during authorized security testing or security-focused code review. Use this skill whenever you are performing reconnaissance on a web application, need to enumerate application functionality and hidden content, want to identify all user-input entry points (URLs, query parameters, POST fields, cookies, HTTP headers), need to fingerprint server-side technologies from HTTP responses, or are building an attack surface inventory before vulnerability testing. Also invoke it when analyzing application behavior to infer server-side structure, looking for undiscovered directories and files through brute-force enumeration, using search engines or web archives to find historical content, probing for hidden debug parameters, mapping functional paths in parameter-driven applications, or producing a behavior-to-vulnerability mapping that prioritizes which areas to probe first. Produces a structured attack surface map: enumerated URLs and functional paths, identified entry points, technology fingerprint, and a prioritized vulnerability-class checklist. Does not perform active exploitation — use this before any active testing phase.
Web Application Fuzzing Automation
Build and execute customized automated attacks against web applications. Use this skill when: systematically enumerating valid identifiers (userids, document IDs, session tokens) by iterating through a parameter range and detecting hits via HTTP status code, response length, response time, Location header, Set-Cookie header, or grep expression; harvesting sensitive data at scale from access-control-flawed endpoints; fuzzing every request parameter with a universal payload kit covering SQL injection (`'`, `'--`, `'; waitfor delay '0:30:0'--`), XSS (`xsstest`, `"><script>alert('xss')</script>`), OS command injection (`|| ping -i 30 127.0.0.1 ; x || ping -n 30 127.0.0.1 &` and separator variants), path traversal (`../../../../../../etc/passwd`, `../../../../../../boot.ini`), script injection (`;echo 111111`, `response.write 111111`), and remote file inclusion (`http://<your-server>/`); selecting the correct Burp Intruder attack type: Sniper (one position cycled through all payloads), Battering Ram (same payload into all positions simultaneously), Pitchfork (parallel payload sets, one per position, advanced in lockstep), or Cluster Bomb (Cartesian product of multiple payload sets across multiple positions); maintaining valid sessions across automated runs using Burp Suite cookie jar, request macros (login, token fetch, multistep pre-requests), and session-handling rules (check session validity, run re-login macro, update token per request); bypassing automation barriers including per-request anti-CSRF tokens (macro extracts token from prior response, session-handling rule injects it), session expiry (validate-and-re-login rule), and CAPTCHA (solution exposed in source, solution replay, OCR, or human-solver integration); triaging results by clicking column headings to sort by status/length/time and Shift-clicking to reverse-sort. Covers JAttack custom Java scripting framework as a reference model for payload source design and response parsing. For authorized penetration testing and application security assessment only.
Web Application Hardening Assessment
Systematically assess a web application's defensive security posture across input validation, information disclosure, application architecture, and server configuration. Use this skill whenever: evaluating the quality of an application's input handling strategy and whether it correctly applies whitelist vs blacklist vs sanitization approaches; assessing whether boundary validation is implemented at each trust boundary (not only the perimeter); checking whether multistep validation and canonicalization ordering are implemented safely; auditing error handling to determine whether verbose error messages, stack traces, debug output, or database banners are exposed to clients; assessing whether server and service banners are suppressed and whether HTML source comments have been removed; evaluating tiered application architecture for trust-boundary segregation weaknesses, dangerous inter-tier trust relationships, and least-privilege violations; assessing shared hosting or cloud environments for customer isolation deficiencies; auditing application server configuration for default credentials, default content, directory listing exposure, dangerous HTTP methods (WebDAV PUT/DELETE), misconfigured proxy functionality, virtual hosting security gaps, and web application firewall effectiveness; performing a pre-deployment security hardening review; conducting a security architecture review or threat modeling session; reviewing a web application penetration test scope for defensive control gaps. Covers core defense mechanisms (Ch2), information leakage prevention (Ch15), architecture security (Ch17), and application server hardening (Ch18). Maps to CWE-20 (Improper Input Validation), CWE-209 (Information Exposure Through Error Message), CWE-16 (Configuration), CWE-284 (Improper Access Control), CWE-693 (Protection Mechanism Failure).
Web Application Penetration Testing Methodology
Orchestrate a complete, structured web application penetration test through 13 testing areas during authorized security assessments. Use this skill when you are conducting a full web application security engagement and need a top-level methodology that sequences and delegates all testing phases — from initial reconnaissance through exploitation. Invoke it to plan and coordinate an engagement end-to-end: mapping application content, analyzing the attack surface, testing client-side controls, assessing authentication and session management, verifying access controls, probing all parameters for injection vulnerabilities, testing function-specific input flaws (SMTP, SOAP, LDAP, XPath, XXE), identifying logic flaws, checking shared hosting and server configuration, and conducting miscellaneous browser-security checks. Also invoke it as the master checklist for ensuring no test area has been missed, when delegating specific areas to domain-specific skills, or when producing a complete security assessment report. This is the hub skill — it calls twelve domain skills and provides the connective workflow between them. For white-box complement and source code analysis use alongside source-code-security-review.
Xss Detection And Exploitation
Detect, exploit, and remediate cross-site scripting (XSS) vulnerabilities across all three varieties — reflected, stored, and DOM-based — in web applications under authorized security testing. Use when conducting penetration tests or security assessments that require identifying XSS entry points, constructing context-aware payloads, bypassing input filters, and producing evidence for remediation.