Continue is an open-source CLI and GitHub integration that automates code review by running AI agents as status checks on every pull request. It’s designed for engineering teams who want to enforce coding standards, security policies, and architectural consistency without manual code review overhead. By defining checks as version-controlled markdown files, teams can treat AI reviews like automated tests—trackable, reviewable, and enforceable.
Built with TypeScript and powered by LLMs, Continue integrates with GitHub via status checks and supports VS Code and JetBrains plugins. Checks are executed via the Continue CLI (cn), which can be deployed in CI/CD pipelines to ensure every PR meets predefined quality criteria before merging.
What You Get
- GitHub Status Checks - AI-powered review results appear directly as GitHub status checks (green/red) on pull requests, with suggested diffs for fixes.
- Source-Controlled AI Checks - AI review rules are defined in markdown files under .continue/checks/ and stored in your repo, making them version-controlled and reviewable like code.
- Security Review Agent - Pre-built template to detect hardcoded secrets, missing input validation, SQL injection risks, and sensitive data logging in PRs.
- CLI Integration (cn) - Command-line tool to run checks locally or in CI, supporting macOS, Linux, and Windows via curl, PowerShell, or npm.
- VS Code & JetBrains Extensions - Native IDE integrations to run and preview AI checks inline during development, not just in PRs.
- CI/CD Enforceable Checks - AI checks can be required as status checks in GitHub, blocking merges until all checks pass with suggested fixes.
Common Use Cases
- Enforcing security standards - A DevSecOps team uses Continue to automatically flag hardcoded API keys and unvalidated API endpoints in every PR, reducing vulnerability exposure.
- Maintaining code consistency - A senior engineer defines a check to ensure all new services use the team’s standardized error response format, enforced on every PR.
- Onboarding new developers - A startup uses Continue to auto-check that new hires follow naming conventions and logging standards, reducing review burden.
- Compliance automation - A fintech company runs AI checks to ensure all database queries use parameterized inputs and no sensitive data is logged to stdout.
Under The Hood
Architecture
- Modular monorepo structure with clearly separated core, GUI, and IDE extension layers, each with independent configuration and build pipelines
- Dependency injection via explicit class instantiation and plugin-style LLM implementations extending a common interface
- Context provider pattern with abstract base class enabling extensible sources like Jira and Git integrations
- Layered configuration system supporting workspace, global, and environment overrides with JSONC parsing and dynamic merging
- Abstracted IDE and tooling interfaces decoupling core logic from editor-specific operations
- Extensible LLM and context architecture with dynamic registration, YAML/JSON configuration, and MCP protocol for remote model orchestration
Tech Stack
- TypeScript-based monorepo with unified build system across core, GUI, and extension modules
- React frontend with Tailwind CSS and Prettier for consistent styling, backed by comprehensive ESLint rules
- Node.js backend with FastAPI for Python services, integrated with AI SDKs and web-tree-sitter for deep code analysis
- SQLite and vectordb for local state and embeddings, enabling offline-first AI functionality
- Development workflow powered by concurrent process monitoring, Husky git hooks, and lint-staged with Prettier for code consistency
Code Quality
- Extensive test coverage spanning unit, integration, and end-to-end scenarios with robust mocking of external dependencies
- Clear separation of concerns with well-defined boundaries between protocol handling, core logic, and platform implementations
- Robust error handling with custom error classes and graceful fallbacks that maintain usability during failures
- Consistent, domain-aligned naming conventions that enhance readability and reduce cognitive load
- Strong type safety enforced through TypeScript interfaces and type guards, especially in configuration and secret resolution paths
- Comprehensive linting and test-driven practices that validate edge cases, immutability, and side-effect isolation
What Makes It Unique
- Native integration of ripgrep for intelligent, dependency-free codebase navigation and search
- Dynamic YAML-based assistant configuration that injects context-aware rules directly into AI workflows
- MCP (Model Control Protocol) enabling seamless, unified switching between diverse LLM providers
- Real-time edit aggregation and diff streaming that treats user edits as atomic, reversible operations
- Rule generation system converting natural language prompts into executable, shareable codebase rules via Markdown templates
- End-to-end tool call rendering in the GUI, transforming AI actions into interactive, previewable steps within the conversation flow