A skill your agent uses when writing the document a buyer reads to say yes — a commercial proposal or Statement of Work, turning discovery notes into a scoped and priced document, adding tiers so…
Install the "proposals" agent skill from https://github.com/ericrisco/rsc-harness/tree/main/skills/proposals into .claude/skills/proposals/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "proposals", then confirm the skill loads.
Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
skills CLI
$ npx skills add ericrisco/rsc-harness --skill proposals -a codex
Project install goes to .agents/skills/; add -g for ~/.codex/skills/.
Install the "proposals" agent skill from https://github.com/ericrisco/rsc-harness/tree/main/skills/proposals into .agents/skills/proposals/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "proposals", then confirm the skill loads.
Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
skills CLI
$ npx skills add ericrisco/rsc-harness --skill proposals -a cursor
Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.
Install the "proposals" agent skill from https://github.com/ericrisco/rsc-harness/tree/main/skills/proposals into .cursor/skills/proposals/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "proposals", then confirm the skill loads.
Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
skills CLI
$ npx skills add ericrisco/rsc-harness --skill proposals -a gemini-cli
Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.
Install the "proposals" agent skill from https://github.com/ericrisco/rsc-harness/tree/main/skills/proposals into .gemini/skills/proposals/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "proposals", then confirm the skill loads.
Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
skills CLI
$ npx skills add ericrisco/rsc-harness --skill proposals -a github-copilot
Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.
Install the "proposals" agent skill from https://github.com/ericrisco/rsc-harness/tree/main/skills/proposals into .github/skills/proposals/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "proposals", then confirm the skill loads.
GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
skills CLI
$ npx skills add ericrisco/rsc-harness --skill proposals -a opencode
OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
Install the "proposals" agent skill from https://github.com/ericrisco/rsc-harness/tree/main/skills/proposals into .opencode/skills/proposals/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "proposals", then confirm the skill loads.
OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
Skill name
proposals
GitHub stars
156
Token cost
~3.3k tokens
SKILL.md length
1,627 words
Files
6 (incl. scripts, references)
Skills in repo
229
Repo updated
First seen
Licence
MIT
At a glance
A skill your agent uses when writing the document a buyer reads to say yes — a commercial proposal or Statement of Work, turning discovery notes into a scoped and priced document, adding tiers so…
Works in 5 steps: The buyer's problem in their own words —… → The success metric — how they'll know it… → A budget signal — band, anchor, or… → …
Writing the document a buyer reads to say yes — a commercial proposal
SKILL.md covers Two artifacts, one job, Route out — do not write the…, Intake gate — STOP if you… and Proposal anatomy, plus 7 more sections
Runs Shell scripts from its folder
What it does
Proposals is an agent skill from ericrisco/rsc-harness. Use when writing the document a buyer reads to say yes — a commercial proposal or Statement of Work, turning discovery notes into a scoped and priced document, adding tiers so the middle one wins, or diagnosing a proposal that will not close. NOT the binding legal agreement with its liability and IP clauses (that is contracts), NOT deciding the number or the margin (that is pricing), NOT the deck that pitches the vision to a room (that is pitch-deck).
Its SKILL.md is about 3.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 8 other files, including scripts and reference files (for example `evals/README.md`, `evals/cases.yaml` and `references/proposal-skeleton.md`).
It sits in Sales & Support, covering Proposals and quotes. The repository describes itself as: Your agent invents things because it has no memory, and can't touch your database because it has no arms. rsc is the meta-harness that gives it both, plus the trade to know the… The licence is MIT.
When your agent uses it
Writing the document a buyer reads to say yes — a commercial proposal
Statement of Work
Turning discovery notes into a scoped and priced document
Adding tiers so the middle one wins
Example prompts
“/proposals”
Requirements
A Bash shell
Workflow steps
5 steps, taken from the first numbered list in SKILL.md.
1The buyer's problem in their own words — the literal phrasing from the call or brief.
2The success metric — how they'll know it worked (a number, a date, a state).
3A budget signal — band, anchor, or stated constraint. Needed to pitch tiers.
4The decision process — who signs, who influences, what timeline.
5Why now — the trigger that makes this urgent.
What it can do on your machine
Read from SKILL.md and the folder at commit 92fde8f. It shows what the files ask for, not the result of running them.
Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Ships 1 file in scripts/ (Shell), which the agent can run.
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
Proposals loads about 3.3k tokens when it runs, and up to ~5.3k if it reads all its reference files. Until then it costs about 118 tokens; SKILL.md has 1,627 words of instructions outside code blocks.
Always· name and description, kept in context so the agent knows when to use it
~118
When it runs· the whole SKILL.md, loaded when a task matches
~3.3k
With references· SKILL.md plus every file in references/, read only if the agent opens them
~5.3k
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
Safety
Auto-check passed
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.
Download SKILL.mdSave it as .claude/skills/proposals/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
proposals
description
Use when writing the document a buyer reads to say yes — a commercial proposal or Statement of Work, turning discovery notes into a scoped and priced document, adding tiers so the middle one wins, or diagnosing a proposal that will not close. NOT the binding legal agreement with its liability and IP clauses (that is `contracts`), NOT deciding the number or the margin (that is `pricing`), NOT the deck that pitches the vision to a room (that is `pitch-deck`).
You write the artifact that converts a discovered need into a yes: the commercial proposal and the Statement of Work (SOW). Your job is persuasion plus scope plus terms — anchored on the buyer's problem in their own words, with explicit inclusions and exclusions, tiered pricing, deliverables that pass or fail against acceptance criteria, milestones, payment terms, and one concrete next step.
You are a close-oriented commercial writer. You consume the price model and hand off binding terms. You do not draft enforceable legal clauses and you do not decide the numbers.
Median proposal-to-close is 25%; top quartile is 35%+ (study of 939 companies, 23,000 opportunities, Optifai 2026-04-20). That is the bar. Most of the lift below is the gap between those two numbers — and it is structural, not prose polish.
Two artifacts, one job
Artifact
What it is
Write it when
Proposal
The persuasive, scoped, priced document the buyer reads to commit. Exec summary → problem → solution → scope → tiers → timeline → proof → terms → next step.
The buyer needs to be convinced and to choose. Default deliverable.
SOW
The scoped/termed annex: inclusions, exclusions, deliverables with acceptance criteria, milestones, change-order clause, payment schedule. Usually a child of an MSA.
Scope must be contractually precise — once they've said "yes, in principle," or the engagement runs under an existing MSA.
A proposal persuades and frames; a SOW pins down. Often you write both: the proposal sells, the SOW (or its scope section) becomes the annex that legal attaches under the MSA.
Route out — do not write the wrong document
The ask
Goes to
Because
MSA, liability/indemnity, IP assignment, governing law, signature-for-enforceability
../contracts/SKILL.md
Binding legal terms — the moment language is enforceable, it is not yours.
"What should we charge? What's the margin / package?"
../pricing/SKILL.md
Deciding the number and the model, not presenting it.
Slide deck to pitch the vision to a room or board
../pitch-deck/SKILL.md
Visual narrative, not a scoped/termed document.
Send it, chase it, move the stage, follow-up cadence
../sales-pipeline/SKILL.md
Tracking and CRM, not authoring.
Deal won — bill it, collect payment
invoicing
Billing after the win.
Cold first-touch to get the meeting
../cold-outreach/SKILL.md
First contact, no scope to propose yet.
Tone, naming, voice rules for the copy
../brand-voice/SKILL.md
You pull voice from there; you don't define it.
The one-sentence boundary: a proposal is the persuasive scoped priced document that gets a buyer to commit; the moment the language becomes binding legal terms it belongs to contracts, and the moment the question is "what number / what model" rather than "how do I present and scope it," it belongs to pricing.
Intake gate — STOP if you can't fill these
You cannot write a proposal that closes from a feature list. Before drafting, you must have:
The buyer's problem in their own words — the literal phrasing from the call or brief.
The success metric — how they'll know it worked (a number, a date, a state).
A budget signal — band, anchor, or stated constraint. Needed to pitch tiers.
The decision process — who signs, who influences, what timeline.
Why now — the trigger that makes this urgent.
Rule: if you cannot personalize the executive summary to this buyer, do not write it yet — interview first. Customized exec summaries close at 34% vs 17% generic; when ~30% of the summary is tailored per client, close rates rise ~50% (Optifai 2026-04-20; DocSend via Thornton & Lowe 2026-06-02). A generic summary literally halves your odds. If you only have a feature list, say so and ask the five questions.
Pull tone and naming from ../brand-voice/SKILL.md before writing prose.
Proposal anatomy
Write these sections in this order. Each earns its place.
Cover / title — client name, project name, date, validity window. Personalization starts on the cover.
Executive summary (200–400 words) — the one section most buyers actually read. Structure: their challenge → your solution → the outcome → the investment. At least ~30% must be specific to this buyer (their words, their metric, their constraint). No solution-features here — outcomes.
Problem framing — restate their problem and its cost in their terms. Earns the right to propose.
Proposed solution — your approach, mapped to the problem. What changes for them.
Scope summary — what's in, with a one-line nod to what's out (full exclusions live in the SOW).
Pricing tiers — Good/Better/Best (next section).
Timeline / milestones — phases with dates, so effort feels concrete.
Proof / qualifications — one or two relevant results, not a logo wall.
Terms summary — payment schedule, validity, what happens next. Binding clauses are referenced, not drafted here.
Next step — the close (see "The close").
Full template and a filled mini-example: references/proposal-skeleton.md.
Tiered pricing — present three, recommend the middle
Single-price quotes leave money and close rate on the table. Three-tier pricing lifts close rate ~23% vs a single price; the middle tier wins ~66% of the time, and the high tier exists to anchor (Optifai 2026-04-20; Freshproposals/INSEAD 2026-06-02). Decide the actual numbers in ../pricing/SKILL.md — here you present them.
Rules:
Name tiers by outcome, not by feature count. "Launch / Scale / Dominate" beats "Tier 1 / Tier 2 / Tier 3."
Mark the middle as recommended. Make it the obvious choice; it should map to what most buyers actually need.
The top tier anchors — it should be visibly more, so the middle looks reasonable.
Each tier states its outcome, not just its inclusions.
text
Bad (single price, feature-framed)
Website redesign — $24,000. Includes 8 pages, CMS, SEO setup, 2 revisions.
Good (three tiers, outcome-framed, middle recommended)
Launch $18k — Get the new site live: 8 pages, CMS, handoff.
Scale $28k ★ recommended — Live + ranking + converting: + SEO, analytics, 90-day tuning.
Dominate $46k — Scale + a measurable pipeline: + landing-page system, A/B program, quarterly review.
Show full SKILL.md (748 more words)Show less
SOW anatomy
The SOW is where vague proposals go to fail. Over 78% of project failures trace to unclear requirements (ITToolKit/Atlassian 2026-06-02). Every section below is load-bearing. Full template: references/sow-skeleton.md.
Scope — explicit EXCLUSIONS. The single most important section. The expensive failure mode is the client assuming a task is in scope while you assumed it was out. State what you are not doing. If it's not listed in inclusions, name it here.
Deliverables with acceptance criteria — a table. Each criterion must be specific enough that a third party can judge pass/fail without asking you. "Looks good" is not a criterion; "loads in <2s on 4G, passes the 6 checks in Appendix A" is.
Milestones and dates — phased, dated, each tied to a deliverable.
Change-order clause — mandatory. Every scope/timeline/budget change requires written approval via a formal change order with updated deliverables, cost, and dates. This is your primary scope-creep defense (Malbek/Icertis 2026-06-02).
Payment schedule — tied to milestones, not the calendar. Deposit → milestone payments → final on acceptance.
MSA reference — the SOW is the child; the MSA is the parent governing legal/payment/IP/dispute terms (Sirion/Ironclad 2026-06-02). Reference it; do not re-litigate its clauses. That referencing is exactly why binding terms route to ../contracts/SKILL.md.
Deliverable table shape
markdown
| # | Deliverable | Acceptance criteria (third-party testable) | Due |
|---|--------------------|-------------------------------------------------------------|---------|
| 1 | Data migration | 100% of 12,400 records migrated; row counts match source; | Week 4 |
| | | 0 records in error queue; client signs off on 20-row sample | |
| 2 | Cutover runbook | Reproduced by a client engineer with no author present | Week 6 |
Scope-creep defense — kill weasel words
Every vague noun is a future free-work argument. Replace each with a quantity, a number, or a bound.
Bad (vague, unbounded)
Good (bounded, testable)
"...and ongoing support, etc."
"30 days post-launch support: up to 10 hrs, email, <1 business-day response."
"Revisions as needed."
"Two rounds of revisions per deliverable; further rounds via change order at $X/hr."
"SEO optimization and more."
"On-page SEO for the 8 listed pages: titles, meta, headings, schema. Off-page is out."
"Content to be provided."
"Client provides final copy for all pages by Week 2; delay shifts the timeline 1:1."
"Scope: TBD."
Never ship a TBD in scope. Resolve it or move it to exclusions.
If a word doesn't survive the question "could two reasonable people read this differently?", rewrite it.
The close — a next step, never "let me know"
Proposals that end with a timeline of specific next steps close ~28% more; pre-handling objections lifts win rate ~19%; no follow-up within 7 days closes 40% less (Optifai 2026-04-20). So:
Mutual action plan: 2–4 dated next steps for both sides (e.g. "Mon: you confirm tier; Tue: we send the SOW; Wed: kickoff"). Not "let me know your thoughts."
Pre-handle 1–2 objections the buyer is likely to raise (price vs scope, timing, risk) before they have to ask.
Validity window — "this pricing holds through [date]" — gives a reason to decide.
One CTA, concrete and singular: sign the tier, book the kickoff, return the SOW. Not three soft options.
Sending and chasing the proposal afterward is ../sales-pipeline/SKILL.md.
Anti-patterns
Anti-pattern
Why it loses
Do instead
Exec summary that lists your features
Buyer reads it first and sees you, not them; generic summaries close at half the rate
Their challenge → your solution → outcome → investment, ~30% tailored
Single price
Leaves ~23% close rate on the table; no anchor, no choice
Three outcome-named tiers, middle recommended
Scope with inclusions but no exclusions
The #1 scope-creep entry point; both sides assume differently
Explicit EXCLUSIONS section naming what you won't do
"Deliver a great website" (unmeasurable)
No way to judge done; final payment stalls
Acceptance criteria a third party can pass/fail
No change-order clause
Every "small extra" is a free-work fight
Written-approval change order with updated cost/date
Liability / IP / governing-law clauses written into the proposal
You're drafting unenforceable or risky legal terms
Reference the MSA; route binding terms to ../contracts/SKILL.md
Closing with "let me know your thoughts"
No decision forcing function; the deal drifts
Dated mutual action plan + one concrete CTA + validity window
Price with no value framing
Buyer compares on cost alone
Tie every tier to its outcome before the number
Verify and hand off
Run scripts/verify.sh <path-to-proposal-or-sow.md> on your draft. It greps for the required sections, flags weasel words (etc., as needed, and more, TBD, unbounded ongoing), warns on smuggled binding-legal language, and sanity-checks exec-summary length. It is a structural lint, not a quality judge — passing it means the contract of sections is intact, not that the prose persuades.
Hand binding terms to ../contracts/SKILL.md, the numbers/model to ../pricing/SKILL.md, post-win billing to invoicing, and send/track to ../sales-pipeline/SKILL.md.
References
references/proposal-skeleton.md — full ordered proposal template + a filled one-page services example.
Proposals next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
Draft a professional agency proposal or pitch document for a prospective client — executive summary, situation analysis, scope of services with a deliverables matrix, KPI targets with baselines and…
A skill your agent uses when the user wants to search Upwork, qualify roles, draft proposals, submit applications, or continue an active Upwork application session.
Simulate a panel of your real prospects and buyers to pressure-test sales and marketing before it goes out — cold emails, pitch decks, landing pages, pricing pages, demo scripts, proposals.
A skill your agent uses when designing or analyzing a controlled experiment — falsifiable hypothesis, sample size from an MDE, reading significance/CI/power, CUPED, or rescuing tests that won't go…
A skill your agent uses when making a web UI conform to WCAG 2.2 Level AA — axe-core or Lighthouse a11y violations, keyboard operability, focus management, ARIA roles/names/live regions, contrast…
A skill your agent uses when running or fixing paid acquisition on Google or Meta — campaign structure (Performance Max, Demand Gen, Search, Advantage+), platform-fit creative, budget/scaling rules…
A skill your agent uses when measuring whether an LLM or agent system actually got better and gating merges on it: golden sets, fixing an inflated LLM-as-judge, scoring RAG (faithfulness, contextual…
A skill your agent uses when a creative goal must become a finished media file: pick and order generative-media models per modality — AI voiceover, image-to-video clips, score — then glue them with…
A skill your agent uses when instrumenting product or web analytics — GA4/PostHog SDK wiring, event taxonomy, funnels, double-counted events, consent gating, PII scrubbing.
A skill your agent uses when writing the document a buyer reads to say yes — a commercial proposal or Statement of Work, turning discovery notes into a scoped and priced document, adding tiers so…. Proposals is an agent skill from ericrisco/rsc-harness. Use when writing the document a buyer reads to say yes — a commercial proposal or Statement of Work, turning discovery notes into a scoped and priced document, adding tiers so the middle one wins, or diagnosing a proposal that will not close.
When should I use Proposals?
Proposals fits situations like: writing the document a buyer reads to say yes — a commercial proposal; statement of Work; turning discovery notes into a scoped and priced document; adding tiers so the middle one wins.
How do I install Proposals in Claude Code?
Run `npx skills add ericrisco/rsc-harness --skill proposals -a claude-code`. Or copy the skill folder (skills/proposals in ericrisco/rsc-harness) into .claude/skills/proposals in your project. Claude Code loads it when a task matches its description.
How do I install Proposals in Codex?
Run `npx skills add ericrisco/rsc-harness --skill proposals -a codex`. Or copy the skill folder (skills/proposals in ericrisco/rsc-harness) into .agents/skills/proposals in your project. Codex loads it when a task matches its description.
Can I use Proposals in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add ericrisco/rsc-harness --skill proposals -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/proposals, .gemini/skills/proposals, .github/skills/proposals and .opencode/skills/proposals in your project.
What does Proposals need to run?
Going by SKILL.md and its folder, Proposals needs a shell for the scripts in its folder. Our summary lists: A Bash shell.
Does Proposals access the network?
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Is Proposals safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.
What licence does Proposals use?
Proposals is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Proposals use?
About 3.3k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 2k tokens, read only when the agent opens those files.
What are the alternatives to Proposals?
Skills that share tags, products or a category with Proposals: Client Proposal (indranilbanerjee/digital-marketing-pro, 854 stars), Rfp Response (mohitagw15856/pm-claude-skills, 1.4k stars), Rfp Scoring Matrix (mohitagw15856/pm-claude-skills, 1.4k stars) and Upwork Application Session (hashgraph-online/awesome-codex-plugins, 1.2k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Proposals?
ericrisco (a GitHub user) maintains it in ericrisco/rsc-harness, which has 156 GitHub stars. The repository holds 229 skills in this directory. The repository was last updated on October 6, 2026.
Source: ericrisco/rsc-harness on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.