Andre's Engineering System

A comprehensive engineering toolkit for Python and TypeScript projects, featuring deployment-focused issue management, technical research capabilities, and specialized code reviewers.

🎯 What's Included

Commands (4)

• /ghi - Generate High-Quality Issues with deployment context
• /evi - Evaluate Issue Quality before implementation
• /tar - Technical Approach Research with Perplexity
• /featureforge - Transform feature ideas into specifications

Agents (12)

Language-Specific Reviewers

• andre-python-reviewer - Python conventions, type hints, FastAPI/Django patterns
• andre-typescript-reviewer - TypeScript type safety, React, modern patterns

Domain Expert Reviewers

• architecture-strategist - SOLID principles, system design, coupling analysis
• performance-oracle - Algorithmic complexity, N+1 queries, bottleneck detection
• data-integrity-guardian - Transaction boundaries, referential integrity
• pattern-recognition-specialist - Design patterns and anti-patterns
• code-simplicity-reviewer - YAGNI principles, simplification opportunities

Research & Analysis

• repo-research-analyst - Codebase structure and pattern analysis
• best-practices-researcher - External best practices research
• framework-docs-researcher - Framework documentation lookup
• git-history-analyzer - Code evolution and archaeology

Meta

• feedback-codifier - Captures feedback to improve reviewer agents (compounding engineering)

🚀 Installation

# Add marketplace
/plugin marketplace add /Users/andrep/Documents/code/andre-engineering-system

# Install plugin
/plugin install andre-engineering-system

📖 Usage

Issue Management

Create deployment-focused issues:

/ghi "Add voice transcription for Telegram bot"

Features:

• Execution context (repos, environments, AWS resources)
• Deployment steps with verification commands
• "AND verified" acceptance criteria pattern
• AWS/infrastructure guidance

Evaluate issue quality:

/evi 42

Checks:

• Agent framework compatibility (9 critical checks)
• Testable acceptance criteria
• Security requirements
• Documentation requirements
• Scores as ready/needs-work/blocked

Technical Research

Research approaches with Perplexity:

/tar "Build real-time voice chat with low latency for web and mobile"

Features:

• Iterative Perplexity research (ask → dig deeper → reason)
• Problem diagnosis and feature architecture
• Comparison matrices for multiple approaches
• Real-world examples and production case studies

Feature Specification

Transform ideas into specs:

/featureforge "Customer referral system with reward tracking"

Creates:

• Problem statement
• User stories
• Acceptance criteria
• Technical specifications

Code Review

Use specialized reviewers:

# Language-specific review
claude agent andre-python-reviewer "Review src/api/endpoints.py"

# Domain expert review
claude agent architecture-strategist "Analyze system design in PR #42"
claude agent performance-oracle "Check for performance issues"

# Research codebase patterns
claude agent repo-research-analyst "How do we handle authentication?"

🏗️ Philosophy

Issue Management

• WHAT vs HOW: Specify requirements (WHAT), not implementation (HOW)
• Deployment = Part of Implementation: Issues aren't done until deployed and verified
• AND verified pattern: Every criterion must include verification command

Code Review

• Language expertise: Python and TypeScript specialists with encoded best practices
• Domain expertise: Architecture, performance, data integrity experts
• Compounding learning: Feedback codifier captures insights to improve reviewers

Research

• Iterative over single-shot: Ask follow-ups, dig into gotchas
• Context is everything: Include environment, constraints, architecture
• Real-world proof: Prioritize production case studies over theory

🔧 Integration with Project-Specific Workflows

This plugin provides universal, reusable tools. It's designed to work alongside project-specific workflows.

Common pattern:

1. Use /tar to research approach
2. Use /featureforge to create spec
3. Use /ghi to create detailed issue
4. Use /evi to validate issue quality
5. Implement (with your project-specific workflow)
6. Review with plugin's specialized agents

📝 Command Details

/ghi - Generate High-Quality Issue

Creates GitHub issues optimized for agent implementation with:

Sections:

• Summary & context
• Execution Context (repos, environments, access methods)
• Requirements (detailed WHAT)
• Implementation Guidance (problems to solve, not solutions)
• Deployment & Verification (copy-paste ready commands)
• Acceptance Criteria ("AND verified" pattern)
• Testing Expectations
• Security & Performance Requirements
• Documentation Requirements
• Common Pitfalls

Philosophy:

• Specify WHAT (requirements), not HOW (implementation)
• Include deployment steps as part of acceptance
• Provide verification commands for every criterion

/evi - Evaluate Issue Quality

Evaluates issues against 9 critical checks:

Critical Checks (Must Pass):

1. Clear Requirements - End state with technical details
2. Testable Acceptance Criteria - Aligns with automated checks
3. Affected Components - Files/modules listed
4. Testing Expectations - What tests to write
5. Context - Why, who, business value

Important Checks (Should Pass): 6. Security Requirements - If handling sensitive data 7. Documentation Requirements - README/wiki updates 8. Error Handling - Error messages, fallback behavior 9. Scope Boundaries - What IS and ISN'T included

Output:

• Compatibility score (X/9)
• Ready for implementation? YES/NEEDS_WORK/NO
• Agent-by-agent analysis
• Specific recommendations

/tar - Technical Approach Research

Comprehensive technical research with Perplexity:

Research Types:

1. Problem Diagnosis - Why something is broken/slow
2. Feature Architecture - Best way to build new feature

Pattern:

1. Start with perplexity_ask (5-20 sec) - initial understanding
2. Dig deeper with follow-ups - gotchas, edge cases
3. Use perplexity_reason (30 sec - 2 min) - implementation details
4. Use perplexity_research (3-10 min) - only for deep dives

Output:

• Executive summary
• 3-4 viable approaches with trade-offs
• Comparison matrix
• Implementation roadmap
• Real-world examples

/featureforge - Feature Specification

Transforms rough ideas into actionable specs:

Process:

1. Asks 3-5 clarifying questions
2. Builds appropriate spec (simple/medium/complex)
3. Outputs formatted specification

Output:

• Problem statement
• Proposed solution
• User stories
• Functional requirements
• Acceptance criteria
• Technical specifications

🎓 Agent Details

Language Reviewers

andre-python-reviewer:

• Type hints and type safety
• Pythonic patterns (comprehensions, context managers)
• FastAPI/Django conventions
• Async/await patterns
• Error handling and logging
• Test structure

andre-typescript-reviewer:

• Type safety (strict mode)
• Modern TypeScript patterns
• React best practices
• Component structure
• State management
• Error boundaries

Domain Expert Reviewers

architecture-strategist:

• SOLID principles
• Service boundaries
• Coupling and cohesion
• Dependency management
• Architectural patterns
• System design decisions

performance-oracle:

• Algorithmic complexity (O(n) analysis)
• N+1 query detection
• Caching opportunities
• Database indexing
• Memory usage
• Bottleneck identification

data-integrity-guardian:

• Transaction boundaries
• Referential integrity
• Race conditions
• Data consistency
• Concurrent access
• Rollback strategies

pattern-recognition-specialist:

• Design patterns (Factory, Strategy, Observer, etc.)
• Anti-patterns detection
• Code smells
• Refactoring opportunities
• Pattern applicability

code-simplicity-reviewer:

• YAGNI (You Aren't Gonna Need It)
• Over-engineering detection
• Unnecessary abstraction
• Simplification opportunities
• Code clarity

Research Agents

repo-research-analyst:

• Codebase structure analysis
• Existing patterns and conventions
• Similar implementations
• Code organization
• Naming conventions

best-practices-researcher:

• External best practices
• Industry standards
• Production examples
• Framework recommendations
• Security guidelines

framework-docs-researcher:

• Official documentation lookup
• Version-specific features
• API references
• Migration guides
• Framework patterns

git-history-analyzer:

• Code evolution
• Change patterns
• Author expertise
• Related changes
• Historical context

Meta Agent

feedback-codifier:

• Analyzes code review feedback
• Extracts patterns and standards
• Updates reviewer agents
• Codifies institutional knowledge
• Enables compounding engineering

🤝 Contributing

This plugin represents a personal engineering system. While it's shared for reference and inspiration, it's tailored to specific workflows and preferences.

📄 License

MIT License - see LICENSE file for details

🔗 Related

• Issue implementation workflows (project-specific)
• Design review systems (project-specific)
• Deployment verification scripts (project-specific)

---

Version: 1.0.0 Author: Andre Pemmelaar (andre@mygentic.ai)