check-existing

Original：🇨🇳 Chinese

Translated

Before implementing a feature, hear out the requirement, then research existing libraries / tools / local packages (monorepo components) that already solve it. Use when scoping a new feature, evaluating build-vs-reuse, or asked to find existing solutions before writing code.

8installs

Sourcenextaltair/altairs-agent-dev-kit

Added on2026-09-05

NPX Install

npx skill4agent add nextaltair/altairs-agent-dev-kit check-existing

SKILL.md Content (Chinese)

View Translation Comparison →

Check Existing Solutions

For the feature to be implemented, first clarify the requirements, then thoroughly investigate whether existing libraries, tools, local packages within the project, or monorepo components can already solve the problem. The goal is to avoid reinventing the wheel and minimize the scope of custom implementations.

When to Use

Before starting work on a new feature (as preliminary research before entering Plan Mode)
When you need to decide whether to build from scratch or use existing solutions
When you want to find the right existing solution from vague requests (e.g., "something for image processing")

You can start this process even if requirements aren't fully finalized; refine them through interviews.

Workflow

Phase 1: Review Past Knowledge

Avoid redundant work by checking existing decisions and lessons learned before starting:

ADR index in
```
docs/decisions/
```
(see
```
docs/decisions/README.md
```
)
Relevant domains in
```
docs/lessons-learned.md
```

Phase 2: Requirement Clarification Interviews (One Question at a Time)

Avoid assumptions and ask specific questions; prioritize multiple-choice formats.

Intent: What specific problem does this feature aim to solve? What are the current pain points?
Technical Details: What is the volume of data to process? Batch or real-time? Which workflow in the project will it be integrated into? Will the operation be GUI-based, automated, or configuration-driven?
Constraints and Priorities: What are the must-have vs. nice-to-have features? What are the performance requirements (speed, memory, accuracy)? Is simplicity a priority?
Search Terms: What is this called in English? Are there any industry terms? Are there any similar tools you know of? What would you search for on PyPI/GitHub?

Phase 3: Organize Requirement Definitions

markdown

## Clarified Requirements
### Core Functions
- Main processing / Input format / Output format
### Technical Requirements
- Integration location (where in the project) / Performance / Relationship with existing dependencies
### Functional Requirements
- Must-have / Nice-to-have / Constraints & Exclusions
### Candidate Search Keywords
- Main / Technical / Domain

Phase 4: Research Existing Solutions

Search within the project first, then search external open-source software (OSS) in stages.

Check for alternatives within the project (highest priority)
- Use the
```
investigation
```
  agent to research existing implementations and similar features
- If the project has local packages or a monorepo structure, check for potential alternatives there
- Use
```
Bash uv tree
```
  /
```
Grep
```
  to check existing dependencies and integration points
Stage-wise search for external OSS
- Stage 1: PyPI / GitHub Topics / Standard libraries (using
```
WebSearch
```
  )
- Stage 2: Implementation examples, comparison articles, Stack Overflow (using
```
WebSearch
```
  /
```
WebFetch
```
  )
- Stage 3: Latest trends and developments (using
```
WebSearch
```
  , specify the current year)
- Retrieve primary library documentation via Context7 MCP (if available) or
```
WebFetch
```
  from official documentation
Evaluate candidates
- Use the
```
solutions
```
  agent to generate and compare multiple candidates (fit, implementation cost, risk)

Phase 5: Evaluate, Document, and Recommend

markdown

# Existing Solutions Research Results

## Requirements (from Phase 3 organization)

## Research Process
- Search keywords / Research sources / Number of discovered candidates

## Discovered Existing Solutions
### 🎯 Fully Replaceable (Fit Score 90%+)
- Library name / Integration method / Recommendation level
### 🔧 Combined Usage (Fit Score 60-89%)
- Main library / Complementation method / Implementation effort
### 📚 Reference Implementation (Fit Score 30-59%)
- Reference value / Scope requiring custom implementation

## Final Recommendation
### ✅ Recommended for Adoption
- Reason for selection / Integration steps / Notes
### ⚠️ When Custom Implementation is Required
- Limitations of existing solutions / Minimum implementation scope / Existing features that can be partially used

Include in your recommendation to document reusable research conclusions (such as library evaluations and build-vs-reuse decision rationale) in project records like ADRs (

docs/decisions/

).

Next Step

Once requirements are finalized and existing solutions are identified, hand over to native Plan Mode (

/plan

) or superpowers

brainstorming

→

writing-plans

. This skill only handles research; it does not cover design or implementation.