write-poc

Generate parameterized, benign proof-of-concept code for security vulnerabilities.

63|8|Updated Feb 16, 2026
One-click install
npx skills add https://github.com/JoranHonig/grimoire --skill write-poc
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: write-poc
Source: https://github.com/JoranHonig/grimoire/tree/main/skills/write-poc
Command: npx skills add https://github.com/JoranHonig/grimoire --skill write-poc

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

Security researchers and auditors often struggle to produce clear, reproducible proof-of-concept code that demonstrably proves a vulnerability while remaining safe and easy for maintainers to run and triage. This skill enforces a structured approach so PoCs are minimal, parameterized, and accompanied by clear explanations and success indicators.

Core Features & Use Cases

  • Structured five-phase workflow: gather details, design exploit flow, choose approach, implement via a delegated gnome, and independently review via a familiar.
  • Safety-first conventions: benign payloads, parameterized targets (localhost/$TARGET), clear header metadata, and a validation script that warns about dangerous patterns.
  • Smart contract and web support: guidance for unit tests, fork tests, Foundry conventions, and integration with forge-poc-templates when appropriate.
  • Practical outputs: generates test-case PoCs, single-file scripts, and reproduction steps that maintainers can run locally for triage and remediation.

Quick Start

Ask the write-poc skill to create a minimal, benign PoC that demonstrates a reflected XSS in /search using alert(1) and targets localhost as a parameterized target.

Frequently Asked Questions about write-poc

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I write a proof-of-concept exploit that is safe and reproducible for vulnerability disclosure?

To write a safe proof-of-concept exploit, use a structured workflow that generates parameterized, benign payloads targeting localhost. This approach ensures PoCs are minimal, testable artifacts accompanied by clear explanations for maintainers to run locally for triage.

What is the best way to create a minimal proof-of-concept for smart contract vulnerabilities?

The best way to create a minimal proof-of-concept for smart contract vulnerabilities is to generate unit tests or fork tests using Foundry conventions. This produces reproducible demonstrations that clearly prove the vulnerability while remaining safe for maintainers to execute.

Can I generate PoC scripts for web application vulnerabilities like reflected XSS?

Yes, you can generate PoC scripts for web application vulnerabilities like reflected XSS. The process creates single-file scripts with benign payloads, such as alert(1), parameterized to target localhost, ensuring the demonstration is safe and easy for maintainers to run locally.

How does the proof-of-concept generation process ensure payloads remain benign?

The PoC generation process ensures payloads remain benign by applying safety-first conventions and a validation script that warns about dangerous patterns. It enforces structured templates, parameterized targets, and independent review steps to verify the exploit demonstration is safe.

Do I need Foundry to generate proof-of-concept code for smart contracts?

Foundry is not strictly required to generate proof-of-concept code, but the workflow provides specific guidance for Foundry conventions and integrates with forge-poc-templates. It also supports general unit tests and single-file scripts for native binaries and web applications.

What are the limitations of using structured templates for security exploit demonstrations?

Structured templates for security exploit demonstrations limit flexibility by enforcing parameterized targets like localhost and benign payloads. If your vulnerability demonstration requires destructive actions or non-parameterized live targets, this safety-first approach will restrict the exploit flow.