Skip to content
Skills Library
Programming · Building & coding

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を作る".

Repository
skills ↗
Licence
MIT
Last repository change
14.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 14.10.2026, without references to retired models or APIs.

Licence

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

I have an idea for a toolbuild a new CLIcreate a new projectkickoff new toolI want to buildlet新しいツールを作りたいCLIを作る

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

  1. When to Use
  2. Workflow
  3. Adapting the Workflow
  4. Tips
  5. Examples
Original SKILL.md headings · 152 lines, 914 words
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…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.