form-strategy skill
✓ VerifiedDesign and audit forms to improve conversion rates, implement validation logic, prevent spam, and ensure clean downstream system integration.
- GitHub stars
- 1,066
- Files
- 3
- Last commit
- Nov 8, 2026
- License
- MIT
- Allowed tools
- —
What does the form-strategy skill do?
form-strategy is an agent skill. Design and audit forms to improve conversion rates, implement validation logic, prevent spam, and ensure clean downstream system integration.
Summary generated from the skill's SKILL.md.
About the form-strategy skill
Designing high-converting forms and protecting them from spam is what this skill enables for product designers and developers. It provides a structured framework to audit existing contact, signup, or checkout forms and plan new ones from scratch. By analyzing field strategy, validation logic, and submission flows, it helps reduce form abandonment and improve completion rates.
An agent should load this skill when a user needs to optimize a multi-step form, implement layered spam defenses like honeypots or Turnstile, or ensure data integrates correctly with downstream systems like a CRM or database. The skill produces comprehensive audit documents that include form inventories, specific recommendations for field reduction, and detailed spam defense plans. It focuses on the structural and behavioral aspects of forms rather than writing the actual backend code or general landing page copy.
What an agent can do with it
- 1Audit existing website formsAnalyze a site's current forms to identify why completion rates are low or why spam is high.
- 2Design a new signup flowPlan the fields and validation logic for a new user registration process to maximize conversions.
Written from the skill's SKILL.md. Every use case is checked against a quote from it.
How to install the form-strategy skill
Each command copies the skill folder into the client's skills directory. Restart the client or start a new session to load it.Install the form-strategy skill in Plugin
/plugin marketplace add rampstackco/claude-skills /plugin install rampstack-skills@rampstack
Install the form-strategy skill in Claude Code
~/.claude/skills/form-strategy/SKILL.md
$ npx degit rampstackco/claude-skills/skills/form-strategy ~/.claude/skills/form-strategyInstall the form-strategy skill in Claude Code (project)
.claude/skills/form-strategy/SKILL.md
$ npx degit rampstackco/claude-skills/skills/form-strategy .claude/skills/form-strategyInstall the form-strategy skill in Codex
~/.agents/skills/form-strategy/SKILL.md
$ npx degit rampstackco/claude-skills/skills/form-strategy ~/.agents/skills/form-strategyInstall the form-strategy skill in Gemini CLI
~/.gemini/skills/form-strategy/SKILL.md
$ npx degit rampstackco/claude-skills/skills/form-strategy ~/.gemini/skills/form-strategyInstall the form-strategy skill in Claude.ai
npx degit rampstackco/claude-skills/skills/form-strategy form-strategy && zip -r form-strategy.zip form-strategy # claude.ai → Customize → Skills → + → Create skill → Upload a skill → form-strategy.zip
Automated checks
Ran Nov 15, 2026Full report →Passed our automated checks. That is not a security audit: read the scripts before you let an agent run them. How checks work
- Source repository linked and reachablerampstackco/claude-skills/skills/form-strategy is public and reachablegithub.com/rampstackco/claude-skills/tree/HEAD/skills/form-s ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit 2026-11-08github.com/rampstackco/claude-skills/commits ↗Pass
- No download-and-run or credential theft in scriptsNo scripts in the skill folderPass
- No hidden instructions in SKILL.mdNo override phrases, safeguard switches, credential requests or hidden charactersgithub.com/rampstackco/claude-skills/blob/HEAD/skills/form-s ↗Pass
- Pre-approved tools are scopedNo pre-approved tools; the agent asks before using onegithub.com/rampstackco/claude-skills/blob/HEAD/skills/form-s ↗Pass
- SKILL.md follows the Agent Skills formatValid name and description; says when to use it; 264 linesgithub.com/rampstackco/claude-skills/blob/HEAD/skills/form-s ↗Pass
SKILL.md
View on GitHubForm Strategy
Forms are where intent becomes action. Design them well or lose conversions, frustrate users, and drown in spam. Stack-agnostic.
When to use
- Designing or redesigning a form
- Conversion is dropping on a key form
- Spam volume is overwhelming the inbox or database
- Auditing forms across a site
- Planning validation logic
- Choosing form tooling (form service, custom build, no-code)
- Integrating forms with CRM, email, or other downstream systems
- Multi-step form decisions
When NOT to use
- Generic conversion optimization (use
cro-optimization) - The copy on the form (use
landing-page-copy) - Backend handling beyond form-specific concerns (use
frontend-component-build,code-review-web) - General accessibility (use
accessibility-audit)
Required inputs
- The form's purpose (what action, what outcome)
- Current form (URL, screenshot, or fields)
- Current performance (completion rate, spam rate, conversion to next step)
- Downstream system (where submissions go: CRM, email, database, support tool)
- Business context (volume, urgency of leads, cost of false vs missed signups)
The framework: 5 dimensions
Every form decision falls into one of these dimensions.
Dimension 1: Field strategy
The biggest lever. Every additional field reduces conversion.
Questions to ask for each field:
- Is this required to deliver value to the user?
- Is this required to deliver value to the business?
- Can it be inferred from another source (email domain, behavior, context)?
- Can it be asked later (after first contact, on second visit, on settings page)?
Default rule: ask for the minimum to make the next step happen. Everything else later.
For a B2B contact form: name and email get you started. Phone, company size, role are nice-to-haves that often hurt conversion more than they help qualification.
For a checkout: country, postal code, address, name, payment. Anything else (referral source, marketing opt-in, account creation) is optional or moved to post-purchase.
Dimension 2: Field design
How each field looks and behaves.
- Labels above inputs beat placeholders. Placeholder labels disappear when typing.
- Inline labels (floating labels) work for very compact forms.
- Single column for almost every form. Eyes flow vertically.
- Logical grouping with visible spacing. Don't put unrelated fields next to each other.
- Right input type:
emailfor emails,telfor phone,numberfor numbers,datefor dates. Mobile keyboards adapt. - Autocomplete attributes:
autocomplete="email",autocomplete="given-name", etc. Browsers and password managers fill them in. - Sensible defaults for fields where one applies (country pre-selected by IP, etc.). Don't default to anything that would mislead if wrong.
Dimension 3: Validation
Tell users what's wrong, when, and how to fix it.
- Validate on blur, not on every keystroke. Inline errors that appear as someone types are jarring.
- Re-validate on submit (catch fields the user skipped).
- Specific messages: "Email must include @" beats "Invalid email."
- Position errors next to the field they refer to.
- Don't submit a form when there are errors. Highlight the first errored field. Scroll to it.
- Validate server-side too. Client validation is UX. Server validation is correctness.
For format-flexible fields (phone numbers, postal codes), validate liberally. Reject only what's clearly wrong, not what's "non-standard." Many phone formats exist.
Dimension 4: Spam defense
Public forms attract spam. Plan for it from day one.
Layered defense:
- Honeypot field. A hidden field that humans don't fill in but bots do. If it's filled, reject silently. Free, low-friction, surprisingly effective for low-effort spam.
- Time-based detection. Reject submissions completed in under 2-3 seconds (bots) or after very long delays (suspicious sessions).
- Rate limiting. Reject if the same IP submits too many times.
- CAPTCHA as a last resort. Modern invisible CAPTCHAs (hCaptcha, reCAPTCHA v3, Turnstile) are low-friction. Old image CAPTCHAs are conversion-killers.
- Behavioral signals. Did the cursor move? Was there scroll? Modern services track this.
- Content filtering. Reject obvious spam content (links, foreign-language content if your audience is local, common spam words).
- Server-side review. A queue rather than direct delivery to inboxes for high-spam-target forms.
For most contact forms: honeypot + time check + Turnstile (or similar) is sufficient.
Dimension 5: Submission flow
What happens after submit.
- Inline success message for short forms. Don't redirect just to confirm.
- Confirmation page for high-value submissions (to provide next steps, set expectations).
- Email confirmation for signups, purchases, RSVPs. Always.
- Save data on errors so the user doesn't re-enter everything.
- Optimistic UI (show success before the server confirms) for low-stakes forms; risky for high-stakes.
For multi-step forms:
- Show progress (3 of 5)
- Save state between steps (in case of refresh or navigation)
- Allow back navigation without losing data
- Validate per step, not just at the end
Workflow
Step 1: Audit current state
For each form on the site:
- What's its purpose?
- Number of fields, required vs optional
- Current completion rate
- Current spam rate
- Validation rules
- What happens after submit
- Where the data goes downstream
Step 2: Define success per form
Different forms have different success metrics:
- Lead form: qualified leads (defined by sales)
- Newsletter: confirmed subscriptions (after double opt-in)
- Contact: substantive replies (not just submissions)
- Checkout: successful payments
Track the metric that matters, not just submissions.
Step 3: Cut fields ruthlessly
Apply the field strategy filter. For each field, answer:
- Required to deliver value? Keep.
- Nice to have? Move to optional or later.
- Used for routing or qualification? Often can be inferred.
A 7-field form becomes a 3-field form. Conversion rises.
Step 4: Set up spam defense
Before launching a public form:
- Add a honeypot field
- Add time-based detection
- Add rate limiting
- Add a modern CAPTCHA if the form is high-traffic or high-spam
After launch, monitor. Tune layers based on what's actually getting through.
Step 5: Improve validation
Walk through each field:
- Is validation specific?
- Does it run at the right time (blur or submit, not on keystroke)?
- Are error messages actionable?
- Is server-side validation matching client-side?
Step 6: Verify accessibility
Critical baseline:
- Every input has an associated label (visually visible or
aria-label) - Errors are associated with inputs (
aria-describedby,aria-invalid) - Focus order matches visual order
- Color isn't the only way to indicate errors
- Form is fully keyboard-navigable
See accessibility-audit for the full WCAG audit.
Step 7: Test downstream
Submit the form. Verify:
- Data lands where it should
- Required fields are populated correctly
- Spam defenses are working (test with a script)
- The user gets the confirmation they expect
- Internal notification is timely
Forms break silently when downstream systems change. Test after any integration update.
Step 8: Monitor
- Completion rate over time
- Spam rate over time
- Errors per submission (high errors = bad UX)
- Drop-off field (where do people abandon?)
Failure patterns
Too many fields. Most B2B contact forms have 3x more fields than they need. Cut.
Validation that fires while typing. Annoying. Causes errors before the user has finished.
Generic error messages. "Invalid input." Where? Why? Be specific.
Required fields not marked. Users discover they're required only after submission fails. Mark required (or, for short forms, mark optional).
Autocomplete disabled. "For security." It's almost never a security improvement and always a UX cost. Leave autocomplete on.
Tab order is broken. Tab key skips fields or jumps backward. Set tabindex only when necessary; use natural DOM order.
Submit button below the fold. Especially on mobile. Users don't see it.
No save on error. User submits, has one error, returns to the form, all fields empty. Nightmare. Save the state.
Captcha as the only spam defense. Captchas are friction. Layered defense beats brute-force friction.
Captcha visible by default. Modern CAPTCHAs (Turnstile, reCAPTCHA v3) are invisible most of the time and only escalate when needed. Use those.
Newsletter signup that's actually a marketing list. Honor opt-in scope. If the user signed up for product updates, don't add them to the marketing newsletter.
Confirmation page that's a dead end. "Thanks for submitting" with no next step. What now? Provide an action (read related content, return to homepage, follow on social).
No double opt-in for marketing email. Bots and typos pollute the list. See email-deliverability for why this matters.
Email field accepting name@ as valid. Browser spec validation is loose. Validate against an actual format.
Custom date pickers worse than native. The native <input type="date"> is now good on most platforms. Don't reinvent unless you have a specific reason.
Forms that lose state on refresh. For long forms, save to localStorage and restore on load.
Output format
A form audit document includes:
- Form inventory: every form on the site
- Per-form review: purpose, fields, performance
- Recommendations: field cuts, validation improvements, spam defense, design changes
- Spam defense plan: layers per form
- Accessibility status: WCAG compliance per form
- Downstream integration map: where each form's data goes
- Monitoring plan: what's tracked
If required data is unavailable
This skill's output depends on data, measurements, or tool results it cannot generate on its own. When a required input, tool, or data source is unavailable or unverifiable, the sanctioned output is the deliverable with the gap stated: what was needed, what was actually obtained or verified, and which parts of the output are affected. Fabricating, estimating, or interpolating a required number to complete the deliverable is never sanctioned. A stated gap is a complete answer.
Reference files
references/form-anatomy-checklist.md: A field-by-field, behavior-by-behavior checklist for auditing or designing a form, covering structure, accessibility, validation, and spam defense.
Files in this skill
3form-strategy skill questions
How do I install the form-strategy skill in Claude Code?
Run npx degit rampstackco/claude-skills/skills/form-strategy ~/.claude/skills/form-strategy. Claude Code loads skills from ~/.claude/skills (all projects) or .claude/skills (one project) and uses a skill when its description matches the task.
Which clients can use the form-strategy skill?
Any client that reads the Agent Skills format: Claude Code, Codex, Gemini CLI and claude.ai (upload as a ZIP). Scripts in the skill run only where the client allows code execution.
How can I reduce form spam without hurting user experience?
Use a layered defense including honeypot fields, time-based detection, rate limiting, and modern invisible CAPTCHAs like Turnstile or reCAPTCHA v3.
What is the best way to handle form validation errors?
Validate on blur rather than on every keystroke to avoid being jarring, provide specific and actionable error messages, and position them next to the relevant field.
How should I approach field selection in a form?
Follow the rule of asking for the minimum required to make the next step happen, as every additional field reduces conversion.