create-issue-gate
Use when starting a new implementation task and an issue must be created with strict acceptance criteria gating before execution.
About this skill
The `create-issue-gate` skill guides an AI agent in generating well-structured GitHub issues as the single entry point for new implementation tasks. Its core functionality is to enforce a hard gate: if explicit, testable acceptance criteria are not provided or inferable, the issue remains in 'draft' status, and task execution is blocked. This ensures that all development efforts are based on clear, verifiable requirements. The skill mandates the inclusion of specific sections in every issue, including Problem, Goal, Scope, Non-Goals, Acceptance Criteria, Dependencies/Blockers, and Status, promoting thorough task definition and accountability.
Best use case
An AI agent needs to initiate a new software development or implementation task and ensure that the task is clearly defined with precise, testable acceptance criteria before any code is written or execution begins.
Use when starting a new implementation task and an issue must be created with strict acceptance criteria gating before execution.
A newly created GitHub issue, adhering to all specified structural requirements (Problem, Goal, Scope, Acceptance Criteria, etc.). The issue's status will initially be 'draft' if acceptance criteria are pending or unclear, or 'ready' if all criteria are met and testable. The implementation task will be effectively gated until valid acceptance criteria are established.
Practical example
Example input
{"user_request": "Start a new task to implement user profile editing. Users should be able to update their email and username. Frontend UI is out of scope for now. We need clear criteria.", "inferred_task_details": {"problem": "Users cannot update their profile information (email, username).", "goal": "Enable authenticated users to update their profile via an API.", "scope": "New API endpoint for profile updates, backend logic for validation and database persistence.", "non_goals": "Frontend UI development, password change functionality, social media integration.", "dependencies": "Existing user authentication system, database schema."}}Example output
{"issue_title": "Implement User Profile Update API Endpoint", "body": "### Problem\nAuthenticated users currently lack the ability to modify their personal profile information such as email address or username.\n\n### Goal\nTo develop and deploy an API endpoint that allows authenticated users to securely update specific fields of their profile (email, username).\n\n### Scope\n- Design and implement a PATCH `/api/v1/profile` endpoint.\n- Implement robust input validation for email and username fields.\n- Update the user record in the database upon successful validation.\n- Handle error cases for invalid data, unauthorized access, and server failures.\n\n### Non-Goals\n- Development of the frontend user interface for profile editing.\n- Implementation of password change or reset functionality (separate task).\n- Integration with social login providers or external services.\n\n### Acceptance Criteria\n- [ ] An authenticated user can successfully send a PATCH request to `/api/v1/profile` to update their email address.\n- [ ] An authenticated user can successfully send a PATCH request to `/api/v1/profile` to update their username.\n- [ ] The system rejects requests with invalid email formats with a 400 Bad Request.\n- [ ] The system rejects requests attempting to update non-updatable fields (e.g., user ID) with a 400 Bad Request.\n- [ ] Unauthenticated requests to `/api/v1/profile` are rejected with a 401 Unauthorized status.\n- [ ] Upon successful update, the API returns a 200 OK status with the updated profile data.\n\n### Dependencies/Blockers\n- Existing and functional user authentication system (ready).\n- Database schema supporting email and username fields (ready).\n\n### Status\ndraft", "status": "draft", "github_url": "https://github.com/sickn33/antigravity-awesome-skills/issues/..."}When to use this skill
- When starting a new feature, bug fix, or development task that requires formal tracking in GitHub.
- To enforce a standard for task definition, ensuring all work has clear goals and boundaries.
- When explicit, testable, and pass/fail checkable acceptance criteria are non-negotiable before proceeding with implementation.
- To prevent an AI agent or developer from starting work on vaguely defined or ambiguous requirements.
When not to use this skill
- For informal tasks, explorations, or research that do not require formal GitHub issue tracking.
- When acceptance criteria are inherently subjective, cannot be easily tested, or are not a strict gating factor.
- If the task is already fully defined and tracked in another system, or does not require a new GitHub issue.
- For tasks that are not related to software implementation or development where the structured criteria are not applicable.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/create-issue-gate/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How create-issue-gate Compares
| Feature / Agent | create-issue-gate | Standard Approach |
|---|---|---|
| Platform Support | Claude | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | easy | N/A |
Frequently Asked Questions
What does this skill do?
Use when starting a new implementation task and an issue must be created with strict acceptance criteria gating before execution.
Which AI agents support this skill?
This skill is designed for Claude.
How difficult is it to install?
The installation complexity is rated as easy. You can find the installation instructions above.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
AI Agents for Coding
Browse AI agent skills for coding, debugging, testing, refactoring, code review, and developer workflows across Claude, Cursor, and Codex.
Best AI Skills for Claude
Explore the best AI skills for Claude and Claude Code across coding, research, workflow automation, documentation, and agent operations.
ChatGPT vs Claude for Agent Skills
Compare ChatGPT and Claude for AI agent skills across coding, writing, research, and reusable workflow execution.
SKILL.md Source
# Create Issue Gate ## Overview Create GitHub issues as the single tracking entrypoint for tasks, with a hard gate on acceptance criteria. Core rule: **no explicit, testable acceptance criteria from user => issue stays `draft` and execution is blocked.** ## When to Use - You are starting a new implementation task and want a GitHub issue to be the required tracking entrypoint. - The work must be blocked until the user provides explicit, testable acceptance criteria. - You need to distinguish between `draft`, `ready`, and `blocked` work before execution begins. ## Required Fields Every issue must include these sections: - Problem - Goal - Scope - Non-Goals - Acceptance Criteria - Dependencies/Blockers - Status (`draft` | `ready` | `blocked` | `done`) ## Acceptance Criteria Gate Acceptance criteria are valid only when they are testable and pass/fail checkable. Examples: - valid: "CreateCheckoutLambda-dev returns an openable third-party payment checkout URL" - invalid: "fix checkout" / "improve UX" / "make it better" If criteria are missing or non-testable: - still create the issue - set `Status: draft` - add `Execution Gate: blocked (missing valid acceptance criteria)` - do not move task to execution ## Issue Creation Mode Default mode is direct GitHub creation using `gh issue create`. Use a body template like: ```md ## Problem <what is broken or missing> ## Goal <what outcome is expected> ## Scope - <in scope item> ## Non-Goals - <out of scope item> ## Acceptance Criteria - <explicit, testable criterion 1> ## Dependencies/Blockers - <dependency or none> ## Status draft|ready|blocked|done ## Execution Gate allowed|blocked (<reason>) ``` ## Status Rules - `draft`: missing/weak acceptance criteria or incomplete task definition - `ready`: acceptance criteria are explicit and testable - `blocked`: external dependency prevents progress - `done`: acceptance criteria verified with evidence Never mark an issue `ready` without valid acceptance criteria. ## Handoff to Execution Execution workflows (for example `closed-loop-delivery`) may start only when: - issue status is `ready` - execution gate is `allowed` If issue is `draft`, stop and request user-provided acceptance criteria.
Related Skills
nerdzao-elite
Senior Elite Software Engineer (15+) and Senior Product Designer. Full workflow with planning, architecture, TDD, clean code, and pixel-perfect UX validation.
nerdzao-elite-gemini-high
Modo Elite Coder + UX Pixel-Perfect otimizado especificamente para Gemini 3.1 Pro High. Workflow completo com foco em qualidade máxima e eficiência de tokens.
multi-platform-apps-multi-platform
Build and deploy the same feature consistently across web, mobile, and desktop platforms using API-first architecture and parallel implementation strategies.
monorepo-architect
Expert in monorepo architecture, build systems, and dependency management at scale. Masters Nx, Turborepo, Bazel, and Lerna for efficient multi-project development. Use PROACTIVELY for monorepo setup,
minecraft-bukkit-pro
Master Minecraft server plugin development with Bukkit, Spigot, and Paper APIs.
memory-safety-patterns
Cross-language patterns for memory-safe programming including RAII, ownership, smart pointers, and resource management.
macos-spm-app-packaging
Scaffold, build, sign, and package SwiftPM macOS apps without Xcode projects.
legacy-modernizer
Refactor legacy codebases, migrate outdated frameworks, and implement gradual modernization. Handles technical debt, dependency updates, and backward compatibility.
i18n-localization
Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.
framework-migration-deps-upgrade
You are a dependency management expert specializing in safe, incremental upgrades of project dependencies. Plan and execute dependency updates with minimal risk, proper testing, and clear migration pa
fp-refactor
Comprehensive guide for refactoring imperative TypeScript code to fp-ts functional patterns
dotnet-backend-patterns
Master C#/.NET patterns for building production-grade APIs, MCP servers, and enterprise backends with modern best practices (2024/2025).