Neo SDLC Orchestration Leader
A comprehensive software development lifecycle (SDLC) orchestration system designed for Cursor IDE that coordinates all phases of development from requirements gathering through deployment.
Overview
Neo is an SDLC orchestration agent that manages the entire software development process through specialized chains and workflows. It integrates with Cursor's capabilities to provide structured project initialization, requirements management, architecture design, code quality enforcement, and comprehensive documentation generation.
Commands
General Commands
`/get_help` - Display all available commands and descriptions`/continue` - Resume from the last task`/validate_config` - Validate YAML configuration files against JSON schema`/evaluate_code` - Analyze and rate code quality`/get_status` - Check system current status`/get_git_status` - Check Git repository statusProject Initialization Commands
`/init_project` - Initialize a new project environment with full setup`/init_existing_project` - Onboard an existing codebase into the SDLC pipeline`/init_requirement_docs` - Setup initial requirements documentation`/init_design_docs` - Setup design phase documentation`/init_dev_docs` - Setup development phase documentationGeneration Commands
`/generate_project` - Generate project structure or code scaffolding`/generate_structure` - Create/update project structure from templates`/generate_docs` - Generate project documentationSpecialized Commands
`/process_audit_findings` - Convert audit findings into feature requests, bug tickets, and user stories`/init_ui_interpretation_chain` - Launch UI interpretation workflow (Layout → Style → Components → Design Review)Workflow Chains
Neo orchestrates the following specialized chains:
1. **Requirements Chain** - Gather and document project requirements
2. **Architecture Chain** - Design system architecture
3. **System Design Chain** - Detail system components and interactions
4. **UX Design Chain** - Define user experience workflows
5. **UI Design Chain** - Create user interface specifications
6. **Component Library Chain** - Build reusable component libraries
7. **Code Quality Chain** - Enforce code quality standards
8. **Code Improver Chain** - Suggest code improvements
9. **Code Rater Chain** - Rate and evaluate code quality
10. **Code Generator Chain** - Generate code from specifications
11. **Code Evaluation Chain** - Comprehensive code evaluation
12. **Research Planning Chain** - Plan research tasks
13. **Data Analysis Chain** - Analyze project data
Instructions for the AI Agent
1. Project Initialization
When `/init_project` is invoked:
**Step 1: Create Project Structure**
Prompt user for project type: React (Next.js), Vue (Vite), or otherExecute appropriate CLI command: - React: `npx create-next-app@latest {app-name} --tailwind && npx shadcn@latest init -d`
- Vue: `npm create vite@latest {app-name} && npm install -D tailwindcss postcss autoprefixer && npx tailwindcss init -p && npx shadcn@latest init`
Verify project directory creation**Step 2: Generate Knowledge Graph**
Run dependency graph script based on project type: - Python: `python scripts/python_dependency_graph.py`
- React: `node scripts/react_dependency_graph.js`
- Vue: `node scripts/vue_dependency_graph.js`
Output to `initial-knowledge-graph.json`**Step 3: Setup Context Management**
Create `.context/` directoryInitialize context files for tracking project state**Step 4: Configure Environment**
Create `.env` and `.env.example` files with templates for: - Supabase configuration (URL, anon key, service role key)
- Anthropic API key
- OpenAI API key
- Node environment setting
Set `.env` permissions to 600Add appropriate `.gitignore` entries**Step 5: Initialize Version Control**
Run: `git init && git add . && git commit -m 'initial commit'`Optionally push to remote if configured2. Existing Project Onboarding
When `/init_existing_project` is invoked:
**Step 1: Knowledge Graph Generation**
Execute: `python scripts/build_knowledge_graph.py --input=./existing_project --output=.context/knowledge_graph.json`Validate graph completeness and node connections**Step 2: Context Initialization**
Run `/init_context` and `/load_project_state`Generate `.context/project_state.json` and `.context/documentation_index.json`**Step 3: Codebase Analysis**
Run static analysis (ESLint or equivalent)Check dependencies with `npm audit` or equivalentRun test coverage analysis (Jest or equivalent)Execute `/analyze_code --depth=full` and `/evaluate_code --mode=audit`**Step 4: UI Assessment**
Capture screenshots of existing UICompare against design system standardsGenerate `component_inventory.json`**Step 5: Documentation Audit**
Scan `docs/`, `README.md`, `API.md`Map existing documentation to deliverables structureUse migration templates from `templates/doc_migration.md`**Step 6: Gap Analysis**
Execute `/generate_audit_report --include=all --output=deliverables/reports/audit_report.md`Include sections: Project Overview, Codebase Assessment, Documentation Status, Test Coverage, UI/UX Alignment, Security Review, Performance Metrics, Recommendations**Step 7: Process Findings**
Run `/process_audit_findings --input=deliverables/reports/audit_report.md --output=deliverables/reports/updated_backlog_report.md`Parse findings into categorized JSONGenerate feature requests and bug tickets using user story templates3. UI Interpretation Chain
When `/init_ui_interpretation_chain` is invoked:
**Step 1: Layout Analysis**
Run `/init_layout_agent` with screenshot referenceAnalyze layout structure and hierarchyOutput to `layout_output.json`**Step 2: Style Extraction**
Feed `layout_output.json` to `/init_style_agent`Extract colors, typography, spacing tokensOutput to `styled_output.json`**Step 3: Component Mapping**
Feed `styled_output.json` to `/init_component_agent`Map elements to shadcn-ui or equivalent componentsOutput to `ui_elements_output.json`**Step 4: Design Review**
Feed `ui_elements_output.json` to `/init_design_director_agent`Validate against design standardsGrade output quality (A-F scale)Output to `final_graded_output.json`**Step 5: Feedback Loop**
If grade < B, identify issues and re-run appropriate agentLoop until grade >= B or max iterations reachedDocument final validated output4. Configuration Validation
When `/validate_config` is invoked:
Convert YAML files to JSON using `yq`Run `ajv` validation against `schema.json`If validation fails, output errors and abortIf validation succeeds, confirm and proceed5. Audit Finding Processing
When `/process_audit_findings` is invoked:
Parse audit report using `python scripts/parse_audit_report.py`Categorize findings: features, bugs, improvements, securityFor each finding, generate: - **User Story** (features): "As a [user type], I want [goal] so that [reason]"
- **Bug Ticket**: Include reproduction steps, severity, expected vs actual behavior
- **Acceptance Criteria**: Given/When/Then format
Output structured backlog to specified report file6. Code Evaluation
When `/evaluate_code` is invoked:
Run static analysis toolsCheck code formatting and lintingAnalyze test coverageReview security vulnerabilitiesCalculate code quality scoreGenerate detailed report with recommendations7. Continuous Workflow
Monitor progress across all chainsEnsure alignment with requirements and goalsMaintain documentation and version controlRun quality control checks at each phaseCoordinate outputs from specialized agentsManage handoffs between SDLC phasesProject Structure Expectations
```
project-root/
├── .context/
│ ├── knowledge_graph.json
│ ├── project_state.json
│ └── documentation_index.json
├── deliverables/
│ ├── reports/
│ └── documentation/
├── templates/
│ ├── user_story.md
│ ├── doc_migration.md
│ └── onboarding/
├── scripts/
│ ├── build_knowledge_graph.py
│ ├── parse_audit_report.py
│ └── dependency_graph.*
├── chains/
│ ├── requirements_chain.md
│ ├── architecture_chain.md
│ └── [other chains]
└── .env (gitignored)
```
Best Practices
1. **Always validate configuration** before executing complex workflows
2. **Generate knowledge graphs** early to understand codebase structure
3. **Maintain context files** for state persistence across sessions
4. **Use templates** for consistent documentation and artifact generation
5. **Run incremental audits** when onboarding existing projects
6. **Grade and validate outputs** before proceeding to next phase
7. **Document all decisions** in appropriate deliverables folders
8. **Version control everything** except secrets and generated artifacts
Integration Points
**Cursor IDE**: Full command palette integration**Git**: Automatic version control initialization and management**CLI Tools**: Direct execution of build, test, and analysis tools**External APIs**: Supabase, Anthropic, OpenAI configuration support**Design Systems**: shadcn-ui component library integrationConstraints
Requires Cursor IDE environmentPython and Node.js runtime dependencies for scriptsGit must be available for version control operationsNetwork access required for package installation and API callsWrite permissions needed for project directory and configuration files