Overview
PatternIO is a static analysis tool designed to address the growing challenge of maintaining code quality and architectural integrity in Java codebases. The platform combines static analysis techniques with modern AI capabilities to detect code smells, identify design patterns, and generate comprehensive architectural documentation.
Built entirely in GoLang as a cross platform CLI tool, PatternIO bridges the gap between academic software engineering principles (GRASP, Gang of Four) and practical developer workflows. It integrates seamlessly into CI/CD pipelines and supports multiple AI providers (GPT, Claude, Gemini, DeepSeek, Groq) to validate findings and reduce false positives, making it a reliable tool for teams seeking actionable architectural insights.
The solution demonstrates how classical software engineering theory can be enhanced with AI to create intelligent, privacy-respecting developer tools that work locally or in automated environments.
Key Features
- Comprehensive code smell detection across 11+ categories (Large Class, Long Method, High Coupling, Low Cohesion, Cyclomatic Complexity, Feature Envy, Data Clumps, and more)
- Complete Gang of Four pattern recognition covering all 23 design patterns across Creational, Structural, and Behavioral categories
- Dual-format UML generation supporting both Mermaid (for Markdown/docs) and Graphviz DOT (for advanced visualization)
- Multi-provider AI validation to filter false positives and provide contextual improvement suggestions
- Flexible analysis profiles (mvp, strict, legacy) tailored to different codebase maturity levels
- Multiple output formats including Console, JSON, TXT, HTML for easy integration
- Web dashboard integration (patternio.dev) for tracking code health evolution over time
- Cross-platform native binaries for Linux, macOS, and Windows
- CI/CD-ready design with JSON output and exit code support
- Privacy-first architecture with optional cloud features and full local operation
Technical Stack
- Language: GoLang (CLI + core analysis engine)
- Architecture: Modular static analysis engine
- Parsing: Custom Java AST parsing and graph modeling
- Concurrency: Goroutines for parallel file analysis and performance optimization
- AI Integration: Multi-provider LLM abstraction layer (GPT, Claude, Gemini, DeepSeek, Groq)
- Output Formats: Console, JSON, TXT, HTML, Mermaid, Graphviz DOT
- Platforms: Linux, macOS, Windows (cross-compiled native binaries)
- API: RESTful integration with web dashboard
- Metrics Engine: CBO, LCOM, Cyclomatic Complexity...
My Contribution
Solo Development & Full-Stack Engineering
- Designed and architected the complete static analysis engine from scratch in Go
- Implemented Java AST parsing and abstract syntax tree traversal logic
- Developed smell detection algorithms with quantitative metrics (CBO, LCOM, complexity thresholds)
- Engineered pattern recognition system for all 23 GoF design patterns
- Built dual-format UML diagram generator (Mermaid + Graphviz) with package splitting support
- Created multi provider AI abstraction layer for LLM integration
- Designed and implemented CLI user experience with profile based configuration
- Developed cross-platform binary compilation and distribution pipeline
- Integrated web dashboard API for cloud-based code health tracking
- Implemented concurrent file processing using Go's goroutine model
- Mapped detected smells to GRASP principles for educational value
Why This Project Matters
This project applies software engineering theory to a real developer tool by combining static analysis with AI to improve accuracy and reduce noise. It addresses a core productivity challenge: maintaining code quality at scale, with a privacy first architecture that runs fully offline. This is production grade engineering, not a prototype. It connects GoF and GRASP design principles to automated, actionable insights and demonstrates systems-level thinking in Go through concurrency, CLI design, and cross platform compilation.
What This Demonstrates
The project demonstrates strong technical depth in software architecture, and design patterns, along with advanced Go development. It includes graph modeling, LLM integration, and prompt engineering for developer tooling. It covers the full product lifecycle: a CLI tool, backend API integration, a web dashboard for visualization, multi platform binary distribution, and an integrated ecosystem that combines local functionality with optional cloud features.