dev-new-tool
/dev-new-tool
End-to-end workflow for taking a new tool idea from research to working MVP. Use when the user has an idea for a CLI tool, library, or small project and wants to go from concept to initial implementation. Triggers on "I have an idea for a tool", "build a new CLI", "create a new project", "kickoff new tool", "I want to build", "let's build a new", "新しいツールを作りたい", "CLIを作る".
- Author
- jackchuka ↗
- Repository
- skills ↗
- Licence
- MIT
- Last repository change
- 14.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 14.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
End-to-end workflow for taking a new tool idea from research to working MVP. Use when the user has an idea for a CLI tool, library, or small project and wants to go from concept to initial implementation. Triggers on "I have an idea for a tool", "build a new CLI", "create a new project", "kickoff new tool", "I want to build", "let's build a new", "新しいツールを作りたい", "CLIを作る".
Triggers from the description
Arguments
/dev-new-tool <tool idea or description>
Original author description
End-to-end workflow for taking a new tool idea from research to working MVP. Use when the user has an idea for a CLI tool, library, or small project and wants to go from concept to initial implementation. Triggers on "I have an idea for a tool", "build a new CLI", "create a new project", "kickoff new tool", "I want to build", "let's build a new", "新しいツールを作りたい", "CLIを作る".
How it works
- When to Use
- Workflow
- Adapting the Workflow
- Tips
- Examples
SKILL.md preview
---
name: dev-new-tool
license: MIT
description: End-to-end workflow for taking a new tool idea from research to working MVP. Use when the user has an idea for a CLI tool, library, or small project and wants to go from concept to initial implementation. Triggers on "I have an idea for a tool", "build a new CLI", "create a new project", "kickoff new tool", "I want to build", "let's build a new", "新しいツールを作りたい", "CLIを作る".
argument-hint: "<tool idea or description>"
compatibility: Requires git and access to the internet
metadata:
author: jackchuka
scope: generic
layer: workflow
confirms:
- scaffold project directory
---
# New Tool Kickoff
A structured workflow for turning a tool idea into a working MVP. Covers the full cycle: research existing solutions, brainstorm approach, write a plan, scaffold the project, build core features, and write documentation.
## When to Use
- User says "I have an idea for a tool/CLI/library"
- User wants to start a new project from scratch
- User wants to research feasibility before building
- Greenfield development of a focused tool or CLI
## Workflow
### Phase 1: Research (Stop point: get user approval before Phase 2)
**Goal:** Understand the landscape before building.
1. **Clarify the idea**: Ask what problem the tool solves, who uses it, and what the core workflow looks like
2. **Search for existing tools**: Web search for similar tools, libraries, or CLIs
3. **Evaluate alternatives**: For each existing tool found:
- What does it do well?
- What gaps or limitations does it have?
- Is it actively maintained?
4. **API/Integration research**: If the tool integrates with external services, research their APIs:
- Authentication methods
- Rate limits and pagination
- Data models and available endpoints
5. **Present findings**: Summarize as a brief landscape overview:
- Existing tools and their limitations
- API capabilities (if applicable)
- Recommended approach based on findings
**Ask the user**: "Based on this research, should we proceed with building? Any adjustments to the concept?"
### Phase 2: Brainstorm & Design (Stop point: get user approval before Phase 3)
**Goal:** Nail down the approach before writing code.
1. **Core features**: Identify the minimum set of features for a useful v1
2. **Technology choices**: Recommend language, frameworks, and key dependencies based on:
- User's preferences and existing projects
- Tool requirements (CLI, TUI, web, library)
- Available ecosystem (Go for CLI tools, TypeScript for Node ecosystem, etc.)
3. **Interface design**: Define the user-facing interface:
- CLI: command structure, flags, arguments
- Library: public API surface
- TUI: key bindings, views
4. **Architecture sketch**: High-level component breakdown (keep it simple — avoid over-engineering)
5. **Name the project**: Suggest a name if the user hasn't chosen one (or invoke the `project-namer` skill)
**Ask the user**: "Here's the proposed design. What adjustments?"
### Phase 3: Plan
**Goal:** Create an executable implementation plan.
1. Write a plan file to the repo (`.claude/plans/[project-name].md` or a location the user specifies)
2. The plan should include:
- **Goal**: One-sentence summary
- **Scope**: What's in v1, what's deferred
- **Steps**: Numbered implementation steps with clear deliverables
- **File structure**: Expected project layout
- **Dependencies**: Key libraries to use
- **Test strategy**: What to test and how
3. Keep the plan concise — under 100 lines. The plan is a contract, not a design doc.
**Ask the user**: "Plan is ready. Proceed with implementation?"
### Phase 4: Scaffold & Build
**Goal:** Get to a working MVP.
1. **Initialize project**:
- Create directory structure
- Initialize module/package (go mod init, npm init, etc.)
- Set up linting and formatting config
- Create .gitignore
2. **Implement core features**: Work through plan steps in order
- Write tests alongside implementation (not after)
- Commit at logical checkpoints
- If a step gets complex, break it down further
3. **Verify**: Run the full test suite, lint, and build before moving on
### Phase 5: Polish & Document
**Goal:** Make the tool usable by others.
1. **README**: Write a README with:
- Clear description and tagline
- Installation instructions
- Quick start / usage examples
- Configuration reference (if applicable)
2. **CLI help**: Ensure all commands have proper help text and examples
3. **License**: Add an appropriate license file (default: MIT unless user specifies)
4. **Final review**: Run a quick scan:
- `go vet` / `eslint` / equivalent for the language
- Check for hardcoded paths or secrets
- Verify README matches actual CLI interface
## Adapting the Workflow
- **If the user already researched**: Skip Phase 1, start at Phase 2
- **If the user has a plan**: Skip to Phase 4
- **If the user wants just research**: Stop after Phase 1
- **If adding to existing project**: Skip scaffolding in Phase 4, focus on the new feature
## Tips
- Prefer simplicity in v1. The user can always add features later.
- For CLI tools, the user prefers Go with cobra/viper patterns.
- Always verify with web search before recommending libraries — check for maintenance status and compatibility.
- Use conventional commits during implementation.
- Don't over-engineer: no feature flags, no plugin systems, no config file formats beyond what's needed for v1.
## Examples
**Example 1: CLI tool from idea**
```
User: "I want to build a CLI tool for Slack using Go"
Action:
1. Research existing Slack CLI tools (slackcli, etc.)
2. Research Slack API capabilities
3. Brainstorm: core commands (messages, channels, search)
4. Plan: write implementation plan
5. Build: scaffold Go project, implement core commands
6. Document: write README with install + usage
```
**Example 2: Research only**
```
User: "I'm thinking of creating some linter. Research if there's anything similar."
Action:
1. Search for existing linters in the relevant space
2. Compare features, limitations, maintenance status
3. Present findings and recommendation
4. Stop — wait for user to decide next steps
```
**Example 3: Tool with external API**
```
User: "I want to create a Fireflies CLI"
Action:
1. Research Fireflies API docs, authentication, endpoints
2. Research existing Fireflies integrations
3. Design: core features (list meetings, get transcript, action items)
4. Plan and build with API client as foundation
```
Versions
The database has no other skills named dev-new-tool.
Identical content appears in 1 other GitHub folders. We show one copy with the highest score.
Database snapshot: 13.11.2026 · package version 93f63bc75a79 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 82idea-to-mvp
Turns an idea note into a one-page spec and a small working prototype, then tracks it as a project. Use when I say build this idea, make an MVP, prototype something, or use my creative block on an idea from Ideas/. - 100mvp-creator
Create comprehensive MVP documentation for Rails applications. Use this skill whenever a user describes a new app idea, wants to explore a SaaS concept, needs competitor research, or is starting a new project from scratch — even if they don't explicitly say "MVP". Triggers on "I… - 82vibe-check
Turn a complete beginner's app idea into a buildable plan, then keep them oriented while they build. Use it whenever someone who has never coded wants to build or "vibe code" an app, has an idea but no idea where to start, or wants it turned into a plan, MVP scope, tech stack,… - 100dev-flow
Orchestrate an end-to-end product-development workflow built on atomic skills. Reads `.workflow/meta.json` in a project directory, works out which phase the user is in (idea → PRD → tasks → design → scaffolded → pages → modules → tests → pre-deploy gates → deployed), and… - 90new-project
Start a new app, tool or service from an idea or spec: confirm scope, set up a reproducible dev environment, keep dependencies minimal and code DRY, and deliver a complete working product in small commits. Use when the user asks to build something from scratch, start from a… - 90build-fast
The default route from "build me X" to something working that a real person can judge - a new app, tool, AI agent or workflow, prototype, MVP, demo or substantial feature - as fast as possible without fooling yourself. Use when the user says build, make, prototype, spin up, get…