| name | full-stack-project-finisher |
| description | Help developers complete projects from 70-100% to production-ready status. Excels at gap analysis, task decomposition, database design, API specifications, and testing strategies. |
| context | fork |
Full-Stack Project Finisher
A specialized skill designed to help developers take projects from 70% complete to production-ready. This skill excels at gap analysis, task decomposition, and providing actionable guidance to complete incomplete projects.
Purpose
This skill addresses the common "Builder's Abundance" pattern - brilliant project starts that need help reaching completion. It provides:
- Gap Analysis - Identifies incomplete work, missing tests, documentation gaps
- Task Decomposition - Breaks large goals into actionable 2-hour sprints
- Tech Stack Optimization - Suggests best tools and patterns for specific needs
- Database Design - Helps design schemas with best practices
- API Blueprint Generation - Creates OpenAPI specs before coding
- Testing Strategy - Builds comprehensive test plans
- Deployment Readiness - Ensures production-ready deployments
When to Use This Skill
Activate this skill when:
- Starting a new full-stack project that needs proper architecture
- A project is 50-80% complete but stalled
- You need to assess what's missing before deployment
- Designing databases or APIs for a new feature
- Planning testing strategy for better coverage
- Preparing a project for production deployment
Core Capabilities
1. Project Gap Analysis
The skill can scan your project and identify:
- Incomplete features (TODOs, FIXMEs, commented code)
- Missing or inadequate tests
- Outdated or missing documentation
- Security vulnerabilities and configuration issues
- Missing error handling
- Database migration gaps
- Deployment blockers
Usage:
python scripts/analyze_project_gaps.py /path/to/project
2. Database Schema Design
Provides PostgreSQL-optimized schema designs with:
- Proper normalization and relationships
- Strategic indexing for performance
- Audit trail patterns
- Soft delete implementations
- UUID vs incremental ID guidance
Usage:
python scripts/generate_db_schema.py --requirements "requirements.txt" --output schema.sql
3. API Blueprint Generation
Creates OpenAPI 3.0 specifications including:
- RESTful endpoint design
- Request/response schemas
- Error handling patterns
- Authentication/authorization flows
- Rate limiting strategies
Usage:
python scripts/create_openapi_spec.py --endpoints "endpoints.yaml" --output api-spec.yaml
4. Test Coverage Analysis
Analyzes test coverage and suggests:
- Missing unit tests for critical functions
- Integration test scenarios
- E2E test flows
- Coverage improvement priorities
Usage:
python scripts/test_coverage_report.py /path/to/project
Reference Documentation
The skill includes curated best practices documentation:
- database_design_patterns.md - PostgreSQL best practices, normalization, indexing strategies
- api_design_patterns.md - REST API standards, versioning, error handling
- testing_strategies.md - Testing pyramid, coverage goals, integration patterns
- deployment_checklist.md - Production readiness requirements
Project Templates
Ready-to-use boilerplates for common stacks:
Node.js + Express + PostgreSQL
assets/backend-templates/node-express-postgres/
├── src/
│ ├── config/
│ ├── controllers/
│ ├── models/
│ ├── routes/
│ ├── middleware/
│ ├── services/
│ └── utils/
├── tests/
├── package.json
└── tsconfig.json
Python + FastAPI + PostgreSQL
assets/backend-templates/fastapi-postgres/
├── app/
│ ├── api/
│ ├── core/
│ ├── models/
│ ├── schemas/
│ └── services/
├── tests/
└── requirements.txt
CI/CD Templates
GitHub Actions workflows for:
- Automated testing on PR
- Code quality checks (linting, type checking)
- Database migrations
- Docker builds
- Deployment automation
Tech Stack Expertise
This skill has deep knowledge of:
Backend:
- Node.js + TypeScript + Express
- Python + FastAPI
- PostgreSQL (schemas, indexes, queries, migrations)
- RESTful API design
- Authentication (JWT, OAuth2)
Testing:
- Jest/Vitest (JavaScript/TypeScript)
- pytest (Python)
- Integration testing patterns
- E2E testing with Playwright/Cypress
- Test coverage analysis
DevOps:
- Docker & docker-compose
- GitHub Actions CI/CD
- Environment configuration
- Deployment strategies
- Monitoring and logging
Workflow Integration
This skill integrates seamlessly with:
- Your existing Claude Code setup
- Session-based workflow patterns
- Git-based development
- Documentation-driven development
- Notion (when integration enabled)
Example Workflows
Complete a Stalled Project
- Run gap analysis:
python scripts/analyze_project_gaps.py .
- Review prioritized gaps
- Create task breakdown for top 3 gaps
- Implement fixes with proper tests
- Re-run analysis to verify completion
- Deploy with confidence
Start a New Full-Stack Feature
- Define feature requirements
- Design database schema:
python scripts/generate_db_schema.py
- Create API specification:
python scripts/create_openapi_spec.py
- Implement backend endpoints
- Write comprehensive tests
- Run coverage analysis
- Deploy to staging
Prepare for Production
- Run full project gap analysis
- Review deployment checklist
- Fix security and configuration issues
- Ensure test coverage > 80%
- Set up CI/CD pipeline
- Create monitoring/logging
- Deploy!
Best Practices
When using this skill, follow these guidelines:
- Always Start with Analysis - Understand what's missing before coding
- Design Before Implementation - Schema and API specs first
- Test as You Build - Don't leave testing for the end
- Document Decisions - Keep ADRs (Architecture Decision Records)
- Incremental Progress - 2-hour focused sprints work best
- Validate Frequently - Re-run analysis after major changes
Customization
You can customize this skill by:
- Adding project-specific patterns to references/
- Creating custom templates in assets/
- Extending scripts for your tech stack
- Adding team-specific best practices
Support and Issues
For questions or issues with this skill:
- Review the reference documentation
- Check script help:
python scripts/<script>.py --help
- Consult Claude Code documentation
- Open an issue in the skill repository
Remember: This skill is designed to help you finish projects, not start them. Use it when you have a clear vision but need help with execution and completion.
