Forge is a full-stack Rust framework. Everything compiles into a single binary backed by PostgreSQL. There is no separate API server, job runner, or cron scheduler -- one binary does it all.
Works with
AI-first code editor with Composer
Before installing skills in Cursor, ensure your development environment meets these requirements:
node --versionforge-idiomatic-engineerExecute the skills CLI command in your project's root directory to begin installation:
Fetches forge-idiomatic-engineer from isala404/forge and configures it for Cursor.
The CLI shows a list of agents. Use arrow keys and space to select Cursor:
Confirm successful installation by checking the skill directory location:
Restart Cursor to activate forge-idiomatic-engineer. Access via /forge-idiomatic-engineer in your agent's command palette.
We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.
Skills execute code in your environment. Always review source, verify the publisher, and test in isolation before production.
Submit your Claude Code skill and start earning
Create detailed user stories, acceptance criteria, and feature specs
Example
Generate user stories for 'password reset feature' with acceptance criteria, edge cases, and test scenarios
Reduce spec writing time by 50%, ensure comprehensive coverage
Research competitors, compare features, identify gaps
Example
Analyze 5 competitor products, create feature comparison matrix, suggest differentiation opportunities
Complete competitive research in 2 hours instead of 2 days
Evaluate features using frameworks (RICE, ICE, Kano) and create prioritized backlogs
Example
Score 20 feature ideas using RICE framework, generate prioritized roadmap with rationale
0
total installs
0
this week
79
GitHub stars
0
upvotes
Run in your terminal
0
installs
0
this week
79
stars
Forge is a full-stack Rust framework. Everything compiles into a single binary backed by PostgreSQL. There is no separate API server, job runner, or cron scheduler -- one binary does it all.
The framework is macro-driven. You write annotated Rust functions and Forge generates the runtime wiring, frontend bindings, and type-safe clients.
Core abstractions:
| Concept | Purpose | Macro | Registration |
|---|---|---|---|
| Query | Read data | #[forge::query] |
.register_query::<FnNameQuery>() |
| Mutation | Write data | #[forge::mutation] |
.register_mutation::<FnNameMutation>() |
| Job | Background task | #[forge::job] |
.register_job::<FnNameJob>() |
| Cron | Scheduled task | #[forge::cron] |
.register_cron::<FnNameCron>() |
| Workflow | Durable multi-step | #[forge::workflow] |
.register_workflow::<FnNameWorkflow>() |
| Daemon | Long-running process | #[forge::daemon] |
.register_daemon::<FnNameDaemon>() |
| Webhook | External events | #[forge::webhook] |
.register_webhook::<FnNameWebhook>() |
| MCP Tool | AI agent tool | #[forge::mcp_tool] |
.register_mcp_tool::<FnNameMcpTool>() |
Naming rule: PascalCase of the function name + type suffix. Declare handlers as pub async fn so generated structs are accessible via functions::StructName. Avoid redundant suffixes (e.g., heartbeat not heartbeat_daemon).
Every handler must be registered in src/main.rs. Macros alone do not make handlers reachable.
Read forge.toml and Cargo.toml to understand the project shape. Check src/main.rs for registered handlers. For frontend work, check frontend/package.json (SvelteKit) or frontend/Cargo.toml (Dioxus).
Make the backend contract real, add tests, then run forge generate to produce frontend bindings. Wire the frontend against the generated output. Never hand-edit generated files (frontend/src/lib/forge/* or frontend/src/forge/*).
Run forge check as the final gate. For UI changes, run forge test for Playwright coverage.
If a port is occupied, DB is unreachable, or a tool is missing: report it and stop. Do not kill processes, change ports, or invent workarounds.
Always load references/pitfalls.md before starting any implementation. It contains critical mistakes that cause production bugs and common build errors with fixes.
| Working on | Load |
|---|---|
| Macro attributes, context methods, error types, config | references/api.md |
| Jobs, workflows, crons, daemons, auth, testing, deploys | references/patterns.md |
| Frontend patterns (shared principles) | references/frontend.md |
| SvelteKit: stores, runes, bindings | references/frontend/svelte.md |
| Dioxus: hooks, signals, bindings | references/frontend/dioxus.md |
| Common mistakes, build failures, runtime errors | references/pitfalls.md |
Thin vertical slices. Make the smallest change that solves the problem. Do not upgrade a bug fix into a redesign.
Tests close to code. Handlers get #[cfg(test)] mod tests in the same file. Test the weird cases by name. Bug fix means regression test. UI change means Playwright test (import test from tests/fixtures.ts).
Boundary validation at handler entry. Validate inputs at the handler level. Use ForgeError types, not panics. Never unwrap() or expect() in handler code -- use ?.
Never edit generated files. If generated output is wrong, fix the Rust source or the codegen.
User scoping is enforced at compile time. Private queries must filter by user_id or owner_id in SQL. Use ctx.user_id() to get the authenticated user's UUID. The macro rejects queries that touch tables without identity filtering. Use #[query(unscoped)] to opt out for shared or admin data.
Transactional integrity. Never call dispatch_job or start_workflow outside a transactional mutation. Without it, jobs execute against uncommitted data.
Migrations use markers. Write -- @up / -- @down in migration files. Do not edit forge_migrations directly. Enable reactivity with SELECT forge_enable_reactivity('table_name'), never hand-write PG triggers.
No fake inputs. If a handler has no business input, omit the parameter. No Option<()>, (), or dummy structs.
For implementation: what changed, tests added, commands run, blockers hit, forge check result.
For review: findings with file references, assumptions, short summary.
Make data-driven prioritization decisions faster
Draft PRDs, status updates, and stakeholder presentations
Example
Create executive summary of Q3 roadmap, monthly progress report, feature launch announcement
Save 3-5 hours/week on communication overhead
Prerequisites
Time Estimate
30-60 minutes to see productivity improvements
Steps
Common Pitfalls
✓ Do
✗ Don't
💡 Pro Tips
✓ Use when
Use for user story writing, competitive research, roadmap prioritization, stakeholder communication, and PRD drafting. Best for reducing repetitive documentation and research work.
✗ Avoid when
Avoid for strategic product vision (requires deep customer empathy), pricing decisions (needs market and financial expertise), or when face-to-face customer discovery is more valuable than speed.
mattpocock/skills
parcadei/continuous-claude-v3
cursor/plugins
ailabs-393/ai-labs-claude-skills
pproenca/dot-skills
mattpocock/skills
forge-idiomatic-engineer is among the better-maintained entries we tried; worth keeping pinned for repeat workflows.
forge-idiomatic-engineer reduced setup friction for our internal harness; good balance of opinion and flexibility.
forge-idiomatic-engineer has been reliable in day-to-day use. Documentation quality is above average for community skills.
Solid pick for teams standardizing on skills: forge-idiomatic-engineer is focused, and the summary matches what you get after install.
Useful defaults in forge-idiomatic-engineer — fewer surprises than typical one-off scripts, and it plays nicely with `npx skills` flows.
We added forge-idiomatic-engineer from the explainx registry; install was straightforward and the SKILL.md answered most questions upfront.
Registry listing for forge-idiomatic-engineer matched our evaluation — installs cleanly and behaves as described in the markdown.
I recommend forge-idiomatic-engineer for anyone iterating fast on agent tooling; clear intent and a small, reviewable surface area.
forge-idiomatic-engineer fits our agent workflows well — practical, well scoped, and easy to wire into existing repos.
Useful defaults in forge-idiomatic-engineer — fewer surprises than typical one-off scripts, and it plays nicely with `npx skills` flows.
showing 1-10 of 46