Prompt Library
Pull battle-tested role and task prompt templates when you want consistent agent output across coding, review, and writing jobs.
Overview
prompt-library is a journey-wide agent skill that supplies role-based and task-specific prompt templates—usable whenever a solo builder needs consistent LLM instructions before committing to work.
Install
npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill prompt-libraryWhat is this skill?
- Curated templates inspired by awesome-chatgpt-prompts and community patterns
- Role-based prompts (expert developer, senior code reviewer) with numbered review steps
- Code reviewer format with severity buckets (e.g. critical issues called out explicitly)
- Covers templates, role-play ('act as X'), and task-specific prompt patterns
- Use when users ask for examples, inspiration, or better prompting—not one-off chat
Adoption & trust: 622 installs on skills.sh; 40.1k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You waste cycles rewriting the same 'act as senior reviewer' or 'expert developer' instructions for every new agent session.
Who is it for?
Builders who want copy-paste prompt starters for development, review, and general task work across the solo journey.
Skip if: Teams that already maintain a locked internal prompt registry with compliance gates—this is an open community pattern library, not policy enforcement.
When should I use this skill?
User needs ready-to-use prompt templates, role-based prompts, examples, inspiration, or task-specific prompt patterns.
What do I get? / Deliverables
You paste or adapt proven prompt patterns so agents follow repeatable review steps, role boundaries, and output formats across tasks.
- Copy-ready role or task prompt blocks
- Structured review or development instruction sets for the active session
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Drop in the expert developer role prompt before asking an agent to refactor React components with SOLID-minded feedback.
Use the senior code reviewer template so findings land in critical-vs-nice-to-have structure before merge.
Adapt role-based 'act as' framing for landing-page or changelog copy without losing a consistent voice.
Reuse structured questioning prompts to compare competitors or summarize docs before you validate scope.
How it compares
A template skill of prose prompts—not an MCP server, not automated evals, and not agent orchestration logic.
Common Questions / FAQ
Who is prompt-library for?
Solo and indie builders who use coding agents daily and want dependable starter prompts instead of improvising system instructions each time.
When should I use prompt-library?
At Idea for research-style role prompts; during Build for implementation and review templates; at Ship for structured code-review prompts; at Launch/Grow for content and support wording—whenever you need examples or 'act as X' patterns.
Is prompt-library safe to install?
It is text-only prompt guidance with no declared tool permissions; review the Security Audits panel on this page before adding any skill to your agent workflow.
SKILL.md
READMESKILL.md - Prompt Library
# 📝 Prompt Library > A comprehensive collection of battle-tested prompts inspired by [awesome-chatgpt-prompts](https://github.com/f/awesome-chatgpt-prompts) and community best practices. ## When to Use This Skill Use this skill when the user: - Needs ready-to-use prompt templates - Wants role-based prompts (act as X) - Asks for prompt examples or inspiration - Needs task-specific prompt patterns - Wants to improve their prompting ## Prompt Categories ### 🎭 Role-Based Prompts #### Expert Developer ``` Act as an expert software developer with 15+ years of experience. You specialize in clean code, SOLID principles, and pragmatic architecture. When reviewing code: 1. Identify bugs and potential issues 2. Suggest performance improvements 3. Recommend better patterns 4. Explain your reasoning clearly Always prioritize readability and maintainability over cleverness. ``` #### Code Reviewer ``` Act as a senior code reviewer. Your role is to: 1. Check for bugs, edge cases, and error handling 2. Evaluate code structure and organization 3. Assess naming conventions and readability 4. Identify potential security issues 5. Suggest improvements with specific examples Format your review as: 🔴 Critical Issues (must fix) 🟡 Suggestions (should consider) 🟢 Praise (what's done well) ``` #### Technical Writer ``` Act as a technical documentation expert. Transform complex technical concepts into clear, accessible documentation. Follow these principles: - Use simple language, avoid jargon - Include practical examples - Structure with clear headings - Add code snippets where helpful - Consider the reader's experience level ``` #### System Architect ``` Act as a senior system architect designing for scale. Consider: - Scalability (horizontal and vertical) - Reliability (fault tolerance, redundancy) - Maintainability (modularity, clear boundaries) - Performance (latency, throughput) - Cost efficiency Provide architecture decisions with trade-off analysis. ``` ### 🛠️ Task-Specific Prompts #### Debug This Code ``` Debug the following code. Your analysis should include: 1. **Problem Identification**: What exactly is failing? 2. **Root Cause**: Why is it failing? 3. **Fix**: Provide corrected code 4. **Prevention**: How to prevent similar bugs Show your debugging thought process step by step. ``` #### Explain Like I'm 5 (ELI5) ``` Explain [CONCEPT] as if I'm 5 years old. Use: - Simple everyday analogies - No technical jargon - Short sentences - Relatable examples from daily life - A fun, engaging tone ``` #### Code Refactoring ``` Refactor this code following these priorities: 1. Readability first 2. Remove duplication (DRY) 3. Single responsibility per function 4. Meaningful names 5. Add comments only where necessary Show before/after with explanation of changes. ``` #### Write Tests ``` Write comprehensive tests for this code: 1. Happy path scenarios 2. Edge cases 3. Error conditions 4. Boundary values Use [FRAMEWORK] testing conventions. Include: - Descriptive test names - Arrange-Act-Assert pattern - Mocking where appropriate ``` #### API Documentation ``` Generate API documentation for this endpoint including: - Endpoint URL and method - Request parameters (path, query, body) - Request/response examples - Error codes and meanings - Authentication requirements - Rate limits if applicable Format as OpenAPI/Swagger or Markdown. ``` ### 📊 Analysis Prompts #### Code Complexity Analysis ``` Analyze the complexity of this codebase: 1. **Cyclomatic Complexity**: Identify complex functions 2. **Coupling**: Find tightly coupled components 3. **Cohesion**: Assess module cohesion 4. **Dependencies**: Map critical dependencies 5. **Technical Debt**: Highlight