Most proposals lose before they’re read —on a missed requirement.
Six skills that run the whole RFP response the way the pros do it (the Shipley process): shred every requirement, decide whether to bid, build the compliance matrix, develop win themes, and draft answers — then a runnable verifier confirms every requirement is addressed before you hit submit. Because one unaddressed mandatory requirement gets your bid thrown out, no matter how good the rest is.
The bid you lost, you probably lost on compliance.
Teams pour days into an RFP response — writing, polishing, perfecting the executive summary — and lose because they missed a mandatory requirement buried on page 34, or blew the page limit, or forgot a required form. The evaluator marks the bid non-responsive and never scores the rest. All that work, gone on a technicality.
And the usual AI shortcut makes it worse: ask a chatbot to “write the proposal” and you get fluent prose that was never checked against the requirements at all — confident, polished, and non-compliant.
In most public and many private RFPs, a single unaddressed mandatory requirement gets the bid ruled non-responsive. The evaluator stops reading — the rest of the proposal never gets scored.
The requirement that sinks you is rarely the headline one. It's buried in Section L, a page limit, a required form — the mechanical compliance items a writer focused on prose never tracked.
A chatbot asked to 'write the proposal' produces confident prose checked against nothing. Polished and non-compliant is still a loss — the writing only counts if the bid survives the checklist.
Clear about the lane. No inflated promises.
- Six production-grade SKILL.md skills that run the Shipley response sequence, with NEVER/ALWAYS guardrails.
- A real, runnable compliance-matrix-verifier.py — stdlib, COMPLETE/INCOMPLETE, non-zero exit as a pre-submission gate.
- Compliance-first by design: shred and matrix before a word is drafted, the way professional proposal teams work.
- A Shipley/APMP primer + a CSV matrix modeled on real public-sector RFP appendices (Section L / Section M aware).
- An AGENTS.md companion for standing proposal discipline, cross-tool by the Agent Skills open standard.
- No fabrication — the drafter marks [PROOF NEEDED], never invents a metric, credential, or client name.
- No bid-on-everything — the engine will recommend no-bid when that's the honest call.
- Not a guarantee of winning — the verifier confirms compliance, not score; a Red Team review still matters.
- Not a document host or e-submission portal — it builds the response; you submit through the buyer's system.
- No SaaS, no monthly fee, no telemetry — your RFP and proposal never leave your environment.
Six skills that run the whole response.
Shred, decide, map, theme, draft, verify — the full proposal motion, in the order the pros do it. Every skill is single-purpose and composes with the others.
“shred this RFP,” “pull the requirements,” “what does this RFP ask for”
Extracts every requirement, instruction (Section L), and evaluation criterion (Section M) into a structured, traceable list. Splits compound requirements; flags ambiguities for a clarifying question. Captures every requirement; invents none.
“should we bid on this,” “can we win this,” “is this worth pursuing”
An honest go/no-go: can we comply, can we win, should we, can we respond in time. Surfaces unmeetable mandatory requirements as blockers. Willing to say no-bid — a disciplined walk-away is a win, not a failure.
“build a compliance matrix,” “track compliance,” “map requirements to sections”
Turns the shredded requirements into the proposal's source of truth — one row per requirement, mapped to its proposal section and status. Outputs verifier-ready CSV, and marks unaddressed requirements honestly (blank means not-yet-done).
“develop win themes,” “what's our angle,” “how do we stand out”
Builds benefit-led themes anchored to the evaluation criteria (Section M), with real discriminators and honest ghosting. Every theme carries substantiable proof — never empty superlatives or invented metrics.
“draft this section,” “answer this requirement,” “write the technical approach”
Drafts answer-first, mirrors the RFP's language and structure, writes to the win theme. Respects page limits. Marks [PROOF NEEDED] rather than fabricating a metric, certification, or client name.
“are we ready to submit,” “did we answer everything,” “Pink Team review”
A real, runnable script that reads the compliance matrix and returns COMPLETE or INCOMPLETE with the gaps — unaddressed, non-compliant, or TBD requirements. Exits non-zero so it gates submission.
Built on the Shipley process — comply before drafting.
The reason this wins where generic AI loses. Shipley Associates codified the modern proposal method — it’s an APMP Approved Training Organization, and its Proposal Guide underpins APMP accreditation. Its core discipline: analyze and comply with every requirement before you write. Each skill is a step in that process.
Shred the RFP and build the compliance matrix first. A proposal written before the requirements are mapped is a proposal that misses some.
The bid/no-bid gate is a real decision point. Walking away from an unwinnable RFP is a disciplined win, not a failure of nerve.
Win themes anchor to the evaluation criteria (Section M) and their weights — you invest effort where the points actually are.
The Pink Team checks compliance and win strategy; here that compliance pass is mechanized by the runnable verifier.
A Shipley primer is included, but you never have to learn the method — the skills apply it for you. That’s the difference between a document that reads well and a proposal built to survive evaluation.
The verifier actually runs. Here’s real output.
This is compliance-matrix-verifier.py against a matrix with an unaddressed mandatory requirement, a non-compliant item, and a TBD — not a screenshot of a promise. It found the three blockers that would sink the bid, flagged the optional item separately, and exited non-zero. Coverage you can prove, not assume.
$ python scripts/compliance-matrix-verifier.py proposal-matrix.csv
INCOMPLETE requirements: 7 (mandatory 6) addressed 5 compliant 3 | critical=3 warning=1
----------------------------------------------------------------------------
MUST FIX BEFORE SUBMIT (would risk a non-responsive bid) (3)
• [unaddressed] row 4: [L.3] Describe your data security program (SOC 2)
Mandatory requirement has no proposal section mapped — it is not
addressed anywhere in the response.
• [noncompliant] row 5: [M.1] Demonstrate 5+ years relevant experience
Mandatory requirement is marked non-compliant or partial. On a
mandatory item this risks a non-responsive determination.
• [status-tbd] row 6: [L.4] Provide a project staffing plan
Mandatory requirement status is still TBD/draft — not confirmed
addressed before submission.
REVIEW (desired items, unconfirmed status) (1)
• [unaddressed] row 7: [L.5] Optional: describe sustainability practices
Verdict: INCOMPLETE. Address the items above before you submit.
$ echo $?
1Stdlib Python, no install. Reads a CSV matrix (opens in Excel), distinguishes mandatory from desired, and separates must-fix blockers from review items. JSON mode for tooling.
The skills chain into one clean workflow.
From a fresh solicitation to a verified, ready-to-submit response — in the order the pros do it.
Shred & decide
RFP Shredder → Bid / No-Bid Evaluator
Pull every requirement, instruction, and evaluation criterion into a traceable list — then make an honest go/no-go before you spend a single proposal hour.
Map & theme
Compliance Matrix Builder → Win Theme Developer
Build the compliance matrix that becomes the proposal's spine, and develop win themes anchored to how the bid will actually be scored.
Draft & verify
Response Drafter → Compliance Verifier
Draft answer-first, compliant, on-theme responses — then run the verifier to confirm every requirement is addressed before you submit.
This engine wins the written bid. Two siblings win the rest.
Exactly what you get for $99, and what you don’t: six skills and a verifier that make a proposal compliant and compelling — not a tool that wins the live competitive call or sets your brand voice. Those are the jobs of the two sales-line products below.
Sales Enablement Battlecard Builder
$79Wins the competitive conversation — battlecards grounded in real intel, honest about where rivals win, usable live in the call. Where this engine wins the written bid, the Battlecard Builder wins the meeting.
Brand Voice Engine
$59A Voice Spec so every win theme and drafted response sounds like one company, not generic AI. Run the engine's drafts through it and the whole proposal reads in your voice.
The questions proposal teams actually ask before buying.
A generic prompt skips the part that actually wins or loses the bid: compliance. This engine follows the Shipley process — the industry-standard proposal method (Shipley Associates is an APMP Approved Training Organization, and its Proposal Guide underpins APMP accreditation) — which insists you analyze and comply with every requirement before you draft a word. So the engine shreds the RFP into a complete requirements list, builds a compliance matrix, decides whether to even bid, develops win themes anchored to the evaluation criteria, and only then drafts. And it ends with a runnable verifier that mechanically confirms every requirement is addressed. It's the difference between a nicely written document and a proposal that survives the evaluator's checklist.
A dependency-free Python script (stdlib, no install) that reads your compliance matrix (a CSV — it opens in Excel) and returns COMPLETE or INCOMPLETE before you submit. It flags every requirement that's unaddressed, every mandatory requirement marked non-compliant or partial, and anything still TBD — with the row and the requirement text. It exits non-zero on INCOMPLETE, so it works as a hard pre-submission gate. This matters because in most public and many private RFPs, a single unaddressed mandatory requirement gets your bid ruled non-responsive — the evaluator stops reading and you're out, no matter how good the rest is. The verifier catches that while you can still fix it.
No — and that's deliberate. One of the six skills is a bid/no-bid evaluator that's willing to recommend walking away. Chasing an unwinnable RFP burns proposal hours, SME time, and the opportunity cost of the bid you could have won. If the company can't meet a mandatory requirement, or the evaluation criteria reward strengths you don't have, the honest answer is no-bid — and the Shipley method treats a disciplined no-bid as a win, not a failure. The engine gives you the real read, not a pep talk.
No. Every drafting and theme skill is built to refuse fabrication. The response drafter never invents a metric, a certification, a client name, or a past-performance result — where proof is needed and missing, it inserts a clearly marked [PROOF NEEDED] placeholder for your team to supply, rather than making something up. The win-theme developer only builds themes you can substantiate. This isn't just integrity — fabrication in a proposal is a material misrepresentation that can void an award. The engine makes your real strengths compelling; it never manufactures fake ones.
You don't need to be technical to get the value. Each skill is a standard SKILL.md folder that installs in Claude (Claude Code, or the skills directory of Codex, Cursor, Gemini, or Copilot) and runs through normal conversation — you upload the RFP and ask it to shred the requirements, and so on. The one runnable piece, the compliance verifier, is a small Python script; if you're in Claude Code the assistant runs it for you, and the output is plain English (COMPLETE/INCOMPLETE with a list). The compliance matrix it reads is just a CSV you already maintain in Excel or Sheets. An AGENTS.md companion is included to keep the discipline (comply before drafting, never fabricate) applied automatically.
Both. The engine is built around the structure federal RFPs use — Section L (instructions to offerors) and Section M (evaluation criteria) — because that's the most rigorous case, and most commercial and state/local RFPs follow the same shape under different labels. The compliance matrix format matches what public agencies actually require (it's modeled on real public-sector compliance appendices). Whether you're an SMB chasing a municipal contract, a B2B vendor responding to an enterprise RFP, or a services firm bidding on government work, the shred → matrix → bid decision → themes → draft → verify workflow is the same.
They're complementary halves of the same revenue motion. This engine wins the formal, written bid — the RFP with a compliance checklist and an evaluation scorecard. The Sales Enablement Battlecard Builder ($79) wins the competitive conversation — the live call where a rival's name comes up. And the Brand Voice Engine ($59) keeps every win theme and drafted response in one consistent company voice. Run the engine's drafts through the Voice Spec and they sound like you, not generic AI. The three are a natural sales-and-proposals set; they're cross-linked at the bottom of each page.
Thirty days, no questions. Here's the honest test: take an RFP you're working on, shred it, build the matrix, and run the verifier against your current draft. If it comes back COMPLETE, you've confirmed your bid is responsive for free. If it returns INCOMPLETE with a mandatory requirement you'd missed — the kind that gets bids thrown out — the engine just paid for itself many times over on a single contract. If it doesn't earn its price, email us and we refund in full.
Stop losing bids on technicalities.
Take an RFP you’re working on, build the matrix, and run the verifier against your draft. If it says COMPLETE, you’ve confirmed your bid is responsive. If it catches a mandatory requirement you’d missed, the engine just paid for itself on one contract. Thirty-day refund either way.
Sold by RedHub AI LLC · Secured by Stripe · redhub.ai