Skip to main content 首页 创作者 lev-os agents workflow-reverse-engineer-specs
workflow-reverse-engineer-specs [WHAT] Reverse-engineer any SaaS product into feature inventory + architecture spec + gap map
[HOW] Multi-source extraction → AI enhancement → synthesis against Lev/AgentPing capabilities
[WHEN] "reverse engineer", "build like this", "spec this product", "feature inventory", "how does X work"
[WHY] Fast path from "I saw a cool product" → actionable build plan with effort estimates
跳到安装 Skills Marketplace 发现并探索由社区构建的 Agent Skills
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/lev-os/agents --skill workflow-reverse-engineer-specs命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
下载 Zip 下载中... Use the codebase knowledge graph for structural code queries. Triggers on: explore the codebase, understand the architecture, what functions exist, show me the structure, who calls this function, what does X call, trace the call chain, find callers of, show dependencies, impact analysis, dead code, unused functions, high fan-out, refactor candidates, code quality audit, graph query syntax, Cypher query examples, edge types, how to use search_graph.
name workflow-reverse-engineer-specs description [WHAT] Reverse-engineer any SaaS product into feature inventory + architecture spec + gap map
[HOW] Multi-source extraction → AI enhancement → synthesis against Lev/AgentPing capabilities
[WHEN] "reverse engineer", "build like this", "spec this product", "feature inventory", "how does X work"
[WHY] Fast path from "I saw a cool product" → actionable build plan with effort estimates
skill_type workflow category research-workflow disable-model-invocation true allowed-tools Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch tags ["workflow","research","reverse-engineering","competitive-analysis","architecture","feature-inventory"] trigger_patterns ["reverse engineer","build like this","spec this product","feature inventory","how does * work under the hood","analyze * architecture"]
Workflow: Reverse-Engineer → Specs
Transform any SaaS product into structured feature inventory, architecture spec, and prioritized build plan with effort estimates.
Every step spawns a fresh subagent . State flows only through handoff artifacts at .lev/pm/handoffs/reng-*.md.
Trigger
User wants to reverse-engineer a product to understand and/or build similar capability
/workflow reverse-engineer-specs <url> [--compare <module>] [--steps <list>] [--depth quick|standard|deep]
Inputs
Input Required Description urlyes Product URL (SaaS web app, demo, or public docs) compareno Lev module to gap-map against (default: community/agentping) stepsno Comma-separated workflow phases to execute (default: all) depthno Extraction depth: quick=pages only, standard=pages+docs+api, deep=pages+docs+api+social output_dirno Override output directory (default: ~/.config/LEV/reverse-eng/sessions/<date>/<product-slug>/)
Steps
Step 1: Discovery & Scrape
Agent Type : Research (haiku)
Skills : skill://lev-research, web scraping
Research :
Visit target URL, identify product name and category
Search for publicly accessible docs (docs., api. , developers.*)
Check for GitHub repo, changelog, blog, case studies
Identify login flows vs public surfaces
Read product tagline and primary use case
Action :
Scrape main landing page + top 3-5 key pages (features, pricing, docs landing)
Save raw HTML/markdown to <session_dir>/artifacts/raw-pages/
Identify and list all discovery URLs: docs, API, changelog, blog
Extract key metadata: product name, tagline, category, launch date, pricing tiers
Create discovery manifest with confidence levels (high/medium/low)
Handoff : .lev/pm/handoffs/reng-1-discovery.md
product_name: <name>
product_tagline: <tagline>
product_category: <category>
primary_use_case: <use case>
homepage_url: <url>
discovery_urls:
docs: <url>
api: <url>
changelog: <url>
blog: <url>
github: <url>
public_surfaces: [<list of accessible pages> ]
session_dir: <path>
Step 2: Extract Features & API Agent Type : Analyst (sonnet)
Skills : skill://lev-research, structured extraction
Research :
Read discovery handoff from Step 1
Parse scraped pages from <session_dir>/artifacts/raw-pages/
Check for API documentation and OpenAPI/GraphQL specs
Review changelog for feature history
Identify component/UI library if publicly documented
Extract all user-facing features: identify primary workflows, secondary features, integrations
Create feature catalog with descriptions, UI hints, and dependencies
If API docs available: parse endpoints, request/response schemas, rate limits, auth methods
If UI component patterns visible: document layout patterns, interaction patterns, state management hints
Build preliminary component catalog (not exhaustive, observation-based)
Save extracted data in structured YAML formats
Handoff : .lev/pm/handoffs/reng-2-extract.md
features_found: <n>
api_documented: true | false
api_endpoints: <n>
component_patterns_observed: <n>
extraction_confidence: <0.0-1.0>
feature_list_path: <path>
api_surface_path: <path>
component_catalog_path: <path>
Step 3: Categorize & Estimate Agent Type : Analyst (sonnet)
Skills : None
Research :
Read extraction handoff from Step 2
Read feature and API catalog files
Review Lev/AgentPing existing capabilities if --compare specified
Categorize each feature into bins: core_api, streaming, components, theming, integrations, infrastructure
Assign effort estimates to each feature: S (1-3 days), M (3-7 days), L (1-2 weeks), XL (2+ weeks)
Mark dependencies: which features depend on others
Note integrations and external services required
Create feature inventory with all metadata
Handoff : .lev/pm/handoffs/reng-3-inventory.md
total_features: <n>
core_features: <n>
secondary_features: <n>
integrations: <n>
estimated_total_effort: <S|M|L|XL>
category_breakdown:
core_api: <n>
streaming: <n>
components: <n>
theming: <n>
integrations: <n>
infrastructure: <n>
feature_inventory_path: <path>
Step 4: Architecture Synthesis Agent Type : Analyst (sonnet)
Skills : skill://lev-research, architecture analysis
Research :
Read all previous handoffs
Read feature inventory
Review scrape artifacts for technical hints
Check for mentions of: tech stack, deployment strategy, data model hints, real-time capabilities
Synthesize request flow diagram: user input → processing → output
Infer data model: core entities, relationships, state management patterns
Document API surface: endpoint categories, authentication, data formats
Identify rendering pipeline: client-side vs server-side, streaming vs batch
Note architectural patterns observed: MVC, event-driven, state machines, etc.
Create architecture document with diagrams (mermaid)
Handoff : .lev/pm/handoffs/reng-4-architecture.md
request_flow_documented: true | false
data_model_inferred: true | false
api_surface_mapped: true | false
rendering_pipeline_identified: true | false
architectural_patterns: [<list> ]
architecture_document_path: <path>
diagram_format: mermaid
Step 5: Gap Mapping (Conditional) Agent Type : Analyst (sonnet)
Skills : None
Research :
Skip this step if --compare not specified
Read all previous handoffs
Read target module code at specified path
Examine target module's feature set, API, components
For each feature in reverse-engineered product: mark status vs target module
has: feature already implemented
partial: feature partially implemented or needs enhancement
missing: not implemented
Reference real file paths in target module for each capability
Identify extension points where feature could be added
Create gap analysis table with all three columns
Recommend priority order for closing gaps
Handoff : .lev/pm/handoffs/reng-5-gap-map.md
compare_module: <path>
total_features: <n>
has_count: <n>
partial_count: <n>
missing_count: <n>
coverage_percentage: <0-100>
gap_map_path: <path>
priority_gaps: [<top 3 -5 missing features> ]
Step 6: Build Plan Generation Agent Type : Analyst (sonnet)
Skills : None
Research :
Read all previous handoffs and documents
Review gap map if available
Consider feature dependencies and effort estimates
Create prioritized phases ordered by dependency and value
Each phase includes:
Phase name and goal
Features included
Key files to modify or create
Estimated duration (e.g., "3-5 days")
Dependencies on prior phases
Success criteria
Optimize for: early wins → core functionality → polish → integrations
Keep phases to 1-2 weeks of effort each
Generate build plan document
Handoff : .lev/pm/handoffs/reng-6-build-plan.md
total_phases: <n>
estimated_duration: <duration>
phase_list_path: <path>
phases:
- name: <phase>
effort: <duration>
feature_count: <n>
depends_on: [<prior phases> ]
Step 7: Report & Synthesis Agent Type : Analyst (sonnet)
Skills : None
Research :
Read all prior handoffs and artifacts
Compile comprehensive evidence
Generate executive summary: what is this product, why it matters, build complexity
Create output directory structure summary
Write final synthesis document tying all findings together
Output single consolidated markdown report suitable for sharing
Handoff : .lev/pm/handoffs/reng-7-final.md
status: complete
product_analyzed: <name>
total_features: <n>
estimated_build_effort: <duration>
report_path: <path>
all_artifacts_generated: true | false
Outputs All files written to ~/.config/LEV/reverse-eng/sessions/<date>/<product-slug>/:
{product-slug}/
├── artifacts/
│ ├── raw-pages/ # Raw HTML/markdown from scrape
│ ├── search_results.json # If web search used
│ └── cache/
├── extraction/
│ ├── raw.md
│ ├── enhanced.md
│ ├── api-surface.yaml
│ └── component-catalog.yaml
├── feature-inventory.yaml # Categorized with effort estimates
├── architecture.md # Request flow + data model + API
├── gap-map.md # (if --compare specified)
├── build-plan.md # Phases with effort estimates
├── final-report.md # Executive summary + synthesis
└── session.json # Metadata
Validation Checklist
Usage Examples
Basic reverse-engineering /workflow reverse-engineer-specs https://www.thesys.dev/
Compare against AgentPing /workflow reverse-engineer-specs https://v0.dev/ --compare community/agentping
Quick extraction only /workflow reverse-engineer-specs https://bolt.new/ --steps extract,enhance,inventory,architecture --depth quick
Deep analysis with gap map /workflow reverse-engineer-specs https://perplexity.ai/ --compare community/agentping --depth deep
Team Structure Role Model Steps Purpose scraper haiku 1-2 Fast discovery and extraction analyst sonnet 3-7 Deep synthesis and planning
Technique Map
Multi-source extraction - Combine homepage + docs + API + social for comprehensive understandingStructured categorization - Sort features by architectural concern (api, ui, infra) for clarityEffort estimation - Realistic time budgets enable prioritizationGap mapping - Direct comparison to target module reveals build prioritiesDependency ordering - Phase sequencing prevents blocking workEvidence preservation - All artifacts saved for team review and iteration
Technique Notes These techniques improve reverse-engineering accuracy and actionability. Evidence-first approach (scrape real products) beats speculation. Structured output enables handoff between team members. Gap mapping bridges "what exists" to "what we build."
Prompt Architect Overlay
Role Definition You are the prompt-architect-enhanced specialist for workflow-reverse-engineer-specs, responsible for deterministic extraction and synthesis of product specifications while preserving team handoff patterns.
Input Contract
Required: valid product URL and clear user intent
Preferred: comparison module path if gap mapping desired, depth preference
If ambiguous: clarify scope (architecture understanding vs build planning vs feature inventory)
Output Contract
Structured handoff files at .lev/pm/handoffs/reng-*.md
All session artifacts in ~/.config/LEV/reverse-eng/sessions/<date>/<slug>/
Validation checklist items verified before declaring steps complete
Actionable build plan with effort estimates and dependency ordering
Edge Cases & Fallbacks
If product is private/behind auth: note access limitations and infer from marketing materials only
If API is undocumented: mark as "inferred from UI behavior" and lower confidence
If scope is too broad: suggest phasing extraction (vertical slices vs features)
If compare module doesn't exist: skip gap mapping and note in handoff
