Hypervelocity Engineering (HVE) Core is an enterprise-ready prompt engineering framework for GitHub Copilot. Constraint-based AI workflows, validated artifacts, and structured methodologies that scale from solo developers to large teams.

Quick Install: Automated installation via the hve-core-installer agent in VS Code (~30 seconds)

HVE Core provides 18 specialized agents, 18 reusable prompts, and 17+ instruction sets with JSON schema validation. The framework separates AI concerns into distinct artifact types with clear boundaries, preventing runaway behavior through constraint-based design.

The RPI (Research → Plan → Implement) methodology structures complex engineering tasks into phases where AI knows what it cannot do, changing optimization targets from "plausible code" to "verified truth."

Recommended for most users: Install HVE Core directly from the VS Code Marketplace for zero-configuration setup:

See Extension Installation Guide for details.

For customization or team version control, use the hve-core-installer agent:

After installing the agent:

1. Open GitHub Copilot Chat in VS Code (Ctrl+Alt+I)
2. Select hve-core-installer from the agent list
3. Enter: "Install HVE Core into my project"
4. Follow the guided installation

The installer will:

• Clone the hve-core repository as a sibling to your workspace
• Validate the repository structure
• Update your VS Code settings.json with custom agent, prompt, and instruction paths
• Make all HVE Core components immediately available

For manual setup or alternative installation methods, see the Getting Started Guide which covers:

• VS Code Extension ⭐ - Marketplace install, zero config
• Multi-Root Workspace - Cross-environment portability
• Submodule - Team version control
• Peer Clone - Local VS Code, solo developers
• Git-Ignored Clone - Devcontainer ephemeral setup
• Mounted Directory - Advanced container sharing
• GitHub Codespaces - Cloud development

• GitHub Copilot subscription
• VS Code with GitHub Copilot extension
• Git installed and available in PATH
• Node.js and npm (for development and validation)

AI coding assistants are brilliant at simple tasks. Ask for a function that reverses a string, and you'll get working code in seconds. Ask for a feature that touches twelve files across three services, and you'll get something that looks right, compiles cleanly, and breaks everything it touches.

The root cause: AI can't tell the difference between investigating and implementing. When you ask for code, it writes code. It doesn't stop to verify that the patterns it chose match your existing modules. AI generally writes first and thinks never.

HVE Core's RPI (Research → Plan → Implement) framework solves this by separating concerns into distinct phases. When AI knows it cannot implement during research, it stops optimizing for "plausible code" and starts optimizing for "verified truth." The constraint changes the goal.

Get started with RPI:

• Why the RPI Workflow Works: the psychology behind constraint-based AI workflows
• Your First RPI Workflow: 15-minute hands-on tutorial
• rpi-agent: autonomous mode for simpler tasks that don't need strict phase separation

HVE Core provides a structured approach to prompt engineering with four artifact types, each serving a distinct purpose:

Key capabilities:

• Protocol patterns support step-based (sequential) and phase-based (conversational) workflow formats
• Input variables use ${input:variableName} syntax with defaults and VS Code integration
• Subagent delegation provides a first-class pattern for tool-heavy work via runSubagent
• Maturity lifecycle follows a four-stage model (experimental → preview → stable → deprecated)

Use the prompt-builder agent to create new artifacts following these patterns.

All AI artifacts are validated through a CI/CD pipeline with JSON schema enforcement:

*.instructions.md → instruction-frontmatter.schema.json
*.prompt.md       → prompt-frontmatter.schema.json
*.agent.md        → agent-frontmatter.schema.json
SKILL.md          → skill-frontmatter.schema.json

The validation system provides:

• Typed frontmatter validation provides structured error reporting.
• Pattern-based schema mapping enables automatic file type detection.
• Maturity enforcement ensures artifacts declare stability level.
• Link and language checks validate cross-references.

Run npm run lint:frontmatter locally before committing changes.

.github/
├── agents/          # Specialized Copilot chat assistants
├── instructions/    # Repository-specific coding guidelines
├── prompts/         # Reusable prompt templates
├── skills/          # Self-contained executable packages
└── workflows/       # CI/CD pipeline definitions
docs/
├── getting-started/ # Installation and first workflow guides
├── rpi/             # Research, Plan, Implement methodology
├── contributing/    # Artifact authoring guidelines
└── architecture/    # System design documentation
extension/           # VS Code extension source
scripts/
├── linting/         # Markdown, frontmatter, YAML validation
└── security/        # Dependency pinning and SHA checks

We appreciate contributions! Whether you're fixing typos or adding new components:

1. Read our Contributing Guide
2. Check out open issues
3. Join the discussion

Microsoft encourages customers to review its Responsible AI Standard when developing AI-enabled systems to ensure ethical, safe, and inclusive AI practices. Learn more at Microsoft's Responsible AI.

This project is licensed under the MIT License.

Security: See SECURITY.md for security policy and reporting vulnerabilities.

Governance: See GOVERNANCE.md for the project governance model.

This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft trademarks or logos is subject to and must follow Microsoft's Trademark & Brand Guidelines. Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship. Any use of third-party trademarks or logos are subject to those third-party's policies.

🤖 Crafted with precision by ✨Copilot following brilliant human instruction, then carefully refined by our team of discerning human reviewers.