DevEx AI Assistant Extension

Complete AI-Powered SDLC Acceleration Platform for Engineering Teams

Overview

The DevEx AI Assistant is a comprehensive VS Code extension that leverages GitHub Copilot to accelerate your entire software development lifecycle - from design validation to code generation to deployment automation. Built for engineering teams to maintain velocity while ensuring principal engineer-level quality standards throughout the SDLC.

What started as a Spring Boot generator has evolved into a complete development workflow assistant that covers:

• 📋 Design review and validation
• 📝 OpenAPI specification generation
• ⚙️ Production-ready code generation
• 🚀 Deployment automation
• 📊 Productivity analytics and ROI tracking

Features

Core Capabilities

Design & Planning Phase

• LLD Review & Validation: AI-powered architectural review with two specialized reviews:
  • Software Engineering Completeness: Comprehensive review (error handling, state management, security, performance, monitoring, operations)
  • API Design Completeness: Ensure LLDs have all details for OpenAPI/code generation
• Design Documentation: Summarize and analyze LLD documents (.md, .txt, .docx)
• Best Practices Guidance: Learn engineering standards through AI feedback

Development Phase

• OpenAPI Spec Generation: Create complete OpenAPI 3.0 specs from LLD documents
• OpenAPI Analysis: Validate and parse existing API specifications
• Spring Boot Project Generation: Complete enterprise-grade microservices from OpenAPI
• Code Review: AI-powered code quality and architecture review
• Endpoint Scaffolding: Quick REST API endpoint generation

Deployment & Operations

• Enterprise Templates: Pre-approved Kubernetes, Docker, and CI/CD configurations
• Deployment Automation: One-click insertion of infrastructure-as-code

Analytics & Productivity

• Productivity Tracking: Built-in telemetry to measure time savings and ROI
• Team Dashboards: Visualize team productivity and AI adoption
• Executive Reporting: ROI calculations and success metrics for leadership

Productivity Dashboard

Track your team's AI-enabled productivity:

• Time saved per engineer
• Projects generated count
• ROI calculations for executive reporting
• Feature usage analytics

Available Commands

Access all commands via Command Palette (Ctrl+Shift+P / Cmd+Shift+P) or context menu:

Design & Planning

• Summarize LLD - AI-powered analysis and summary of design documents
• Review LLD - Comprehensive architectural review (includes API completeness check)
• Generate OpenAPI Spec from LLD - Create complete OpenAPI 3.0 specifications

Development & Code Generation

• Generate Spring Boot Project - Complete enterprise-grade microservices
• Parse OpenAPI Spec - Validate and analyze API specifications
• Review Code - AI-powered code quality and architecture review
• Add REST Endpoint - Quick endpoint scaffolding (coming soon)

Deployment & Infrastructure

• Insert Deployment Template - Add Kubernetes/Docker/CI-CD configurations

Analytics & Tracking

• View Productivity Dashboard - Team metrics, time savings, and ROI
• Check for Updates - Stay current with internal releases

Prerequisites

Required (for using the extension)

• VS Code: Version 1.85.0 or higher
• GitHub Copilot: Active subscription (uses existing Copilot license)

Optional (only for building/running generated projects)

• JDK: Java 17 or 21 (only needed to build and run generated Spring Boot projects)
• Maven/Gradle: Build tools (only needed to compile and run generated projects)

Note: Most extension features (LLD review, summarization, OpenAPI generation, templates) work without any additional tools. Java and build tools are only required if you want to compile and run the generated Spring Boot projects.

Installation

Internal Distribution (Current)

1. Download the latest .vsix file from your internal GitHub releases page
2. In VS Code, go to Extensions view (Ctrl+Shift+X)
3. Click the ... menu → "Install from VSIX..."
4. Select the downloaded .vsix file
5. Restart VS Code

The extension will automatically check for updates from the configured internal repository.

Quick Start

Complete SDLC Workflow (Design → Code)

Step 1: Write Your LLD

Create a detailed Low-Level Design document with your API specifications.

Step 2: Review for Completeness ⭐ NEW!

Before generating code, ensure your LLD has all necessary details:

1. Right-click your LLD file → "Review LLD"
2. Select "API Design Completeness"
3. AI checks for:
   - Complete endpoint definitions (HTTP methods, paths, parameters)
   - Detailed request/response schemas with validation rules
   - HTTP status codes and error handling
   - Security/authentication specifications
   - Data models and constraints
4. Review AI feedback and update your LLD
5. Re-run review until AI says "READY"

See our guides:

• 📋 LLD API Design Checklist - Comprehensive guide
• ⚡ Quick LLD Review Guide - Fast reference

Step 3: Generate OpenAPI Spec ⭐ NEW!

Once your LLD is complete:

1. Right-click your LLD file → "Generate OpenAPI Spec from LLD"
2. Provide:
   - Service name
   - API version
   - Format preference (YAML/JSON)
   - Whether to include examples and security definitions
3. Review and save the generated OpenAPI spec

Step 4: Generate Spring Boot Project

Now generate production-ready code:

Generate Your First Spring Boot Project

1. Prepare Your Inputs:

   • ✅ Reviewed LLD document (use Step 2 above)
   • ✅ OpenAPI specification (generated in Step 3 or existing)

2. Run the Generator:

   • Open Command Palette: Ctrl+Shift+P
   • Type: DevEx: Generate Spring Boot Project
   • Follow the prompts:
     • Estimate manual development time (for ROI tracking)
     • Choose output directory
     • Select OpenAPI spec file
     • (Optional) Select LLD document
     • Configure project details (name, package, Java version, etc.)

3. Review Generated Project:

   • Complete Maven/Gradle project structure
   • REST controllers from OpenAPI endpoints
   • Service and repository layers
   • Exception handling and validation
   • OpenAPI documentation setup
   • Unit test scaffolding
   • README with getting started instructions

4. Build and Run:

   cd <your-project>
   mvn spring-boot:run
   # or
   gradle bootRun
   

5. Access Your API:

   • Application: http://localhost:8080/api
   • Swagger UI: http://localhost:8080/api/swagger-ui.html
   • Health Check: http://localhost:8080/api/actuator/health

Complete End-to-End Workflow

┌─────────────────────────────────────────────────────────────┐
│  Phase 1: Design & Validation                               │
├─────────────────────────────────────────────────────────────┤
│  1. Write LLD with detailed API specifications              │
│  2. ⭐ Review LLD → "API Design Completeness"                │
│     • AI checks 40+ completeness criteria                   │
│     • Get specific actionable feedback                      │
│     • Iterate until AI says "READY"                         │
│  3. ⭐ Generate OpenAPI Spec from LLD                        │
│     • Complete OpenAPI 3.0 YAML/JSON                        │
│     • Includes all schemas, validation, errors              │
└─────────────────────────────────────────────────────────────┘
                           ↓
┌─────────────────────────────────────────────────────────────┐
│  Phase 2: Code Generation                                   │
├─────────────────────────────────────────────────────────────┤
│  4. Generate Spring Boot Project from OpenAPI               │
│     • Complete enterprise-grade microservice                │
│     • Controllers, services, repositories                   │
│     • Exception handling, validation, tests                 │
│  5. (Optional) Review Code for quality assurance            │
└─────────────────────────────────────────────────────────────┘
                           ↓
┌─────────────────────────────────────────────────────────────┐
│  Phase 3: Deployment & Operations                           │
├─────────────────────────────────────────────────────────────┤
│  6. Insert Deployment Templates                             │
│     • Kubernetes manifests                                  │
│     • Docker configurations                                 │
│     • CI/CD pipelines                                       │
│  7. Push to Git → Automated deployment                      │
└─────────────────────────────────────────────────────────────┘
                           ↓
┌─────────────────────────────────────────────────────────────┐
│  Phase 4: Analytics & Continuous Improvement                │
├─────────────────────────────────────────────────────────────┤
│  8. View Productivity Dashboard                             │
│     • Track time saved across all phases                    │
│     • Team adoption metrics                                 │
│     • ROI calculations for leadership                       │
└─────────────────────────────────────────────────────────────┘

Cumulative Time Savings Across SDLC:

• Design Review: Manual (2 hours) → AI (5 minutes) = 95% faster
• OpenAPI Creation: Manual (2 hours) → AI (2 minutes) = 98% faster
• Project Scaffolding: Manual (4-8 hours) → AI (15 minutes) = 94% faster
• Deployment Setup: Manual (2 hours) → AI (5 minutes) = 96% faster
• Total: 10-14 hours → 27 minutes = 96% reduction 🚀

Use Cases Beyond Spring Boot

While Spring Boot generation is a core feature, this extension accelerates multiple development scenarios:

1. Design Review & Validation

Use Case: Comprehensive review to ensure production-ready designs

• Commands:
  • Review LLD → "Software Engineering Completeness" (comprehensive: error handling, state, security, performance, ops)
  • Review LLD → "API Design Completeness" (API-focused: endpoints, schemas, status codes)
• Benefit: Catch design issues early, validate completeness, ensure all engineering aspects are covered
• Users: Architects, Tech Leads, Senior Engineers, All Engineers before implementation

2. OpenAPI Specification Creation

Use Case: Creating API contracts from design documents

• Command: Generate OpenAPI Spec from LLD
• Benefit: Consistent, complete API specifications in minutes
• Users: API Designers, Backend Engineers, Integration Teams

3. Documentation & Knowledge Sharing

Use Case: Understanding existing LLDs or onboarding new team members

• Command: Summarize LLD
• Benefit: Quick understanding of complex designs
• Users: New Engineers, Cross-functional Teams, Documentation Writers

4. Code Quality Assurance

Use Case: Reviewing codebases for quality, security, and best practices

• Command: Review Code
• Benefit: Principal engineer-level feedback in seconds
• Users: All Engineers, Code Reviewers, QA Teams

5. Infrastructure as Code

Use Case: Standardizing deployment configurations across projects

• Command: Insert Deployment Template
• Benefit: Enterprise-approved configs, zero configuration drift
• Users: DevOps Engineers, Platform Teams, All Developers

6. Team Productivity Analytics

Use Case: Measuring AI adoption and ROI for leadership

• Command: View Productivity Dashboard
• Benefit: Data-driven decisions on AI investment
• Users: Engineering Managers, Directors, Executives

Quick Start by Role

👨‍💻 For Backend Engineers

Primary workflow: Complete microservice development

1. Prepare Your Inputs:

   • ✅ Reviewed LLD document (use design review feature)
   • ✅ OpenAPI specification (generated from LLD or existing)

2. Run the Generator:

   • Command: DevEx: Generate Spring Boot Project
   • Follow prompts for project configuration
   • Review generated enterprise-grade code

3. Build and Deploy:

   cd <your-project>
   mvn spring-boot:run
   # Access at http://localhost:8080/api
   # Swagger UI: http://localhost:8080/api/swagger-ui.html
   

🏛️ For Architects & Tech Leads

Primary workflow: Design review and validation

1. Review LLDs for comprehensive engineering completeness:

   • Command: DevEx: Review LLD → "Software Engineering Completeness"
   • Validates: error handling, state management, security, performance, monitoring, operations
   • Get detailed feedback with actionable checklists

2. Review LLDs for API completeness (if API-focused):

   • Command: DevEx: Review LLD → "API Design Completeness"
   • Ensures teams have complete API specifications for code generation

3. Generate standard API specifications:

   • Command: DevEx: Generate OpenAPI Spec from LLD
   • Validate API designs before implementation

4. Track team productivity:

   • Command: DevEx: View Productivity Dashboard
   • Monitor adoption and ROI

🔌 For API Designers & Integration Teams

Primary workflow: API specification creation

1. Write detailed API design in LLD
2. Run: DevEx: Generate OpenAPI Spec from LLD
3. Use generated spec for:
   • Frontend/backend contracts
   • API documentation
   • Mock server generation
   • Client SDK generation
   • Multi-language code generation

🚀 For DevOps & Platform Engineers

Primary workflow: Infrastructure standardization

1. Access standardized templates:

   • Command: DevEx: Insert Deployment Template
   • Choose from Kubernetes, Docker, CI/CD templates

2. Ensure consistency across projects:

   • All projects use approved configurations
   • Zero configuration drift
   • Easy updates via extension

📊 For Engineering Managers & Directors

Primary workflow: Team productivity and ROI tracking

1. Monitor team metrics:

   • Command: DevEx: View Productivity Dashboard
   • Time saved per engineer
   • Feature adoption rates
   • Project velocity improvements

2. Generate executive reports:

   • Export metrics for leadership presentations
   • Calculate ROI on AI tooling investment
   • Track continuous improvement trends

Configuration

Access via VS Code Settings (Ctrl+,) → Search "DevEx"

Project Defaults

{
  "devex-ai-assistant.springBoot.version": "3.4.1",
  "devex-ai-assistant.java.version": "21",
  "devex-ai-assistant.buildTool": "maven",
  "devex-ai-assistant.packageName": "com.yourcompany"
}

Telemetry & Updates

{
  "devex-ai-assistant.telemetry.enabled": true,
  "devex-ai-assistant.updates.checkOnStartup": true,
  "devex-ai-assistant.updates.githubReleasesUrl": "https://github.com/yourorg/devex-ai-assistant/releases"
}

AI Model Selection

{
  "devex-ai-assistant.ai.modelFamily": "claude",
  "devex-ai-assistant.ai.modelSelector": {
    "vendor": "copilot",
    "family": "claude"
  }
}

Enterprise Templates

Adding Your Organization's Templates

1. Navigate to extension installation:

   .vscode/extensions/yourorg.devex-ai-assistant-x.x.x/templates/
   

2. Add templates to appropriate folders:

   • kubernetes/ - Deployment manifests, services, ingress
   • docker/ - Dockerfiles, docker-compose configurations
   • ci-cd/ - GitHub Actions, Azure Pipelines, Jenkins

3. Use Handlebars syntax for dynamic values:

   name: {{projectName}}
   image: registry/{{artifactId}}:{{version}}
   

4. Engineers insert via: DevEx: Insert Deployment Template

Productivity Metrics & ROI

Individual Engineer Tracking

• Personal Dashboard: DevEx: View Productivity Dashboard
• Track your time saved across all SDLC phases:
  • Design review time
  • OpenAPI generation time
  • Code generation time
  • Deployment setup time
• Compare manual vs. AI-assisted development
• See your productivity trends over time

Team & Leadership Analytics

The extension automatically tracks:

• Total time saved across entire team
• Phase-by-phase breakdown (Design, Development, Deployment)
• Feature adoption rates (which commands are most used)
• Project velocity (projects per engineer per quarter)
• Quality metrics (code review feedback, iterations needed)
• ROI calculation: (Time Saved × Hourly Rate) - Tooling Investment

Export Metrics: Dashboard includes "Export Data" button for executive reporting

Real-World ROI Examples

Scenario 1: Backend Development Team

Team: 10 engineers
New microservices per quarter: 20
Time saved per service: 10 hours (design + code + deployment)
Hourly rate: $75

Quarterly Savings: 20 × 10 × $75 = $15,000
Annual Savings: $60,000

Scenario 2: API-First Organization

Team: 50 engineers across multiple teams
LLD reviews per month: 100
OpenAPI specs generated per month: 80
Spring Boot projects per quarter: 40

Time saved:
- LLD reviews: 100 × 1.5 hours = 150 hours/month
- OpenAPI generation: 80 × 1.5 hours = 120 hours/month
- Project generation: 40 × 6 hours = 240 hours/quarter

Monthly savings: (150 + 120) × $75 = $20,250
Quarterly project savings: 240 × $75 = $18,000
Annual total: ($20,250 × 12) + ($18,000 × 4) = $315,000

Scenario 3: Enterprise Platform Team

Organization: 200 engineers
Using extension for various SDLC phases
Average time saved per engineer per month: 4 hours
Hourly rate: $85

Monthly savings: 200 × 4 × $85 = $68,000
Annual savings: $816,000

Generated Project Structure (Spring Boot)

my-service/
├── pom.xml (or build.gradle)
├── README.md
├── .gitignore
├── src/
│   ├── main/
│   │   ├── java/com/company/myservice/
│   │   │   ├── MyServiceApplication.java
│   │   │   ├── config/
│   │   │   │   └── OpenApiConfig.java
│   │   │   ├── controller/
│   │   │   │   └── [Generated from OpenAPI]
│   │   │   ├── service/
│   │   │   │   └── [Business logic layer]
│   │   │   ├── repository/
│   │   │   │   └── [Data access layer]
│   │   │   ├── model/
│   │   │   │   ├── entity/
│   │   │   │   └── dto/
│   │   │   └── exception/
│   │   │       └── GlobalExceptionHandler.java
│   │   └── resources/
│   │       └── application.yml
│   └── test/
│       └── java/
│           └── MyServiceApplicationTests.java
└── (Optional) kubernetes/, docker/, .github/workflows/

Best Practices

1. Start with Design Review

• Before coding, run LLD review with "API Design Completeness"
• Fix all critical issues identified by AI
• Ensure design has all necessary details for code generation
• Use the LLD API Checklist as reference

2. Generate, Then Validate

• Generate OpenAPI specs from reviewed LLDs
• Validate generated specs before sharing with teams
• Use generated specs as contracts between frontend/backend
• Share specs early for feedback and alignment

3. Leverage Code Generation Strategically

• Generated code provides 70-80% foundation
• Focus human effort on business logic and edge cases
• Use generated tests as starting point, expand coverage
• Review generated code for learning opportunities

4. Standardize with Templates

• Use organizational deployment templates consistently
• Maintain standard CI/CD pipelines across projects
• Follow security and compliance guidelines
• Update templates centrally, teams inherit changes

5. Track and Optimize

• Estimate manual time honestly for accurate ROI
• Provide feedback when prompted (👍/👎)
• Review personal dashboard weekly
• Share success stories with team and leadership

6. Continuous Learning

• AI feedback teaches best practices - read it carefully
• Improve LLD quality based on AI suggestions
• Share learnings across teams
• Contribute to template library

7. Iterate and Improve

• Don't expect perfection on first generation
• Iterate on designs based on AI feedback
• Refine generated code as needed
• Keep extension updated for new features

Troubleshooting

Permission Popup Not Appearing

Issue: The popup to allow the extension to use AI models doesn't appear after installation.

Solution:

1. Check Copilot Status: Ensure GitHub Copilot is signed in and working

   • Open Copilot Chat and verify it responds
   • Command Palette → "GitHub Copilot: Sign In" if needed

2. Manually Grant Permissions:

   • Open Command Palette (Ctrl+Shift+P or Cmd+Shift+P)
   • Type: "Preferences: Open User Settings (JSON)"
   • Add this line:

     "github.copilot.chat.languageModelAccess": {
       "devex-ai-assistant": true
     }
     

3. Trigger Permission Request:

   • Try using any extension command (e.g., "DevEx: Summarize LLD Document")
   • This should trigger the permission popup
   • Click "Allow" when prompted

4. Reload VS Code:

   • Command Palette → "Developer: Reload Window"
   • Try using the extension again

5. Check Output Logs:

   • View → Output → Select "DevEx AI Assistant"
   • Look for specific error messages

GitHub Copilot Not Available

Error: "GitHub Copilot is not available"

Solution:

1. Ensure Copilot extension is installed
2. Check Copilot subscription status
3. Sign in to GitHub: Command Palette → "GitHub: Sign In"
4. Restart VS Code

OpenAPI Parsing Fails

Error: "Failed to parse OpenAPI specification"

Solution:

1. Validate spec at https://editor.swagger.io
2. Ensure file is valid YAML/JSON
3. Check OpenAPI version (3.0+ supported)
4. Review error message for specific issues

Generated Code Won't Compile

Solution:

1. Check Java version: java -version (need 21+)
2. Verify Maven/Gradle installation
3. Run mvn clean install or gradle clean build
4. Check dependency resolution (network/proxy issues)
5. Review generated pom.xml/build.gradle

Templates Not Showing

Solution:

1. Verify templates exist in extension folder
2. Check file naming (must have extensions like .yml, .yaml, .md)
3. Reload VS Code: Developer: Reload Window

FAQ

Q: Do I need a separate AI API key? A: No! The extension uses your existing GitHub Copilot license via VS Code's Language Model API.

Q: What data is collected? A: All telemetry is stored locally in ~/.devex-ai-assistant/metrics.json. No cloud transmission. Data includes: project generation timestamps, time estimates, feature usage.

Q: Can I customize generated code templates? A: Yes! Advanced users can modify templates in the extension installation folder. See Customization Guide.

Q: What Spring Boot version is used? A: Configurable, default is 3.4.1 (latest stable). Change via settings.

Q: Does this work with microservices architecture? A: Yes! Generate each microservice independently. Use organizational templates for service mesh, API gateway configurations.

Q: Can I generate projects without LLD? A: Yes, LLD is optional. At minimum, provide an OpenAPI specification.

Q: How do I justify this to leadership? A: Use the Productivity Dashboard to show concrete ROI. Export metrics showing time saved, multiply by team's loaded hourly rate.

Q: Is this approved for production use? A: Generated code follows best practices but requires code review. Treat as accelerated scaffolding, not production-ready without review.

Q: Can I contribute improvements? A: Yes! This is an internal project. Contact the DevEx team or open issues on internal GitHub.

Support

Internal Resources

• Slack: #devex-ai-assistant
• Email: devex-team@yourcompany.com
• GitHub: https://github.com/yourorg/devex-ai-assistant (issues, discussions)
• Wiki: Internal confluence/wiki page

Getting Help

1. Check this README and FAQ
2. Search existing GitHub issues
3. Post in Slack channel
4. Contact DevEx team directly

Roadmap

The extension continues to evolve from a Spring Boot generator into a comprehensive SDLC automation platform.

Current Capabilities (v1.1+)

• ✅ LLD Review & Validation
• ✅ OpenAPI Spec Generation from LLD
• ✅ Spring Boot Project Generation
• ✅ Code Review & Quality Analysis
• ✅ Deployment Template Management
• ✅ Productivity Analytics & ROI Tracking

Upcoming Features (v1.2-2.0)

Short Term (Next Quarter):

• 🚧 Add REST Endpoint: Incremental endpoint addition to existing projects
• 📋 Database Migration Scripts: Auto-generate Flyway/Liquibase migrations
• 📋 Enhanced Test Generation: Integration and E2E test scaffolding
• 📋 More Language Support: Node.js, Python backend generation

Medium Term (6 months):

• 📋 Multi-Module Projects: Microservice ecosystems with service-to-service
• 📋 Frontend Generation: React/Angular from OpenAPI specs
• 📋 Security Scaffolding: OAuth2, JWT, RBAC templates
• 📋 Performance Testing: JMeter/Gatling script generation

Long Term (12 months):

• 📋 Complete SDLC Coverage: 50+ commands covering all phases (see PROJECT_BRAINSTORM.md)
• 📋 Team Intelligence: Learn from team's coding patterns
• 📋 Plugin Architecture: Custom commands for org-specific needs

Your Feedback Shapes the Roadmap

This is an evolving platform built for engineers, by engineers:

• What saves you the most time? We'll prioritize those features
• What templates are missing? We'll add them
• What pain points remain? We'll solve them
• What languages/frameworks? We'll expand support

Share your ideas via:

• Internal Slack channel
• GitHub issues
• Monthly feedback sessions
• Direct message to DevEx team

Summary: Beyond Spring Boot Generation

What started as a Spring Boot code generator has become a comprehensive AI-powered development platform that accelerates your entire SDLC:

📋 Design Phase → API Design Completeness Checking

Engineers get instant feedback on their designs, ensuring completeness before coding begins. Time savings: 2 hours → 5 minutes per design.

📝 Specification Phase → OpenAPI Generation

Transform design documents into production-ready API specifications automatically. Time savings: 2 hours → 2 minutes per spec.

⚙️ Development Phase → Code Generation

Generate enterprise-grade Spring Boot microservices with best practices baked in. Time savings: 4-8 hours → 15 minutes per project.

🚀 Deployment Phase → Infrastructure Automation

One-click deployment template insertion with organizational standards. Time savings: 2 hours → 5 minutes per project.

📊 Analytics Phase → ROI Tracking

Measure and demonstrate the value of AI tooling to leadership. $300K-$800K+ annual savings for enterprise teams.

🎯 The Result

96% reduction in SDLC overhead - spend more time on business logic, less on boilerplate.

This isn't just a code generator. It's your AI-powered development partner across the entire software lifecycle. 🚀

Contributing

Internal contributors welcome! See CONTRIBUTING.md for guidelines.

License

Internal use only - Proprietary to [Your Company Name]

Acknowledgments

• DevEx Team: Building tools to accelerate development
• Early Adopters: Pilot team feedback was invaluable
• GitHub Copilot: Powering the AI capabilities
• Spring Boot Community: For excellent documentation and patterns

---

Get Started Today!

1. Install the extension
2. Generate your first project
3. Share feedback in #devex-ai-assistant
4. Help us measure the productivity impact!

Questions? Reach out to the DevEx team. We're here to help! 🚀

---

Last Updated: January 2025 | Version 1.0.0