What Is the `just check` Command in Macro? A Complete Guide to Local Verification

The just check command in the Macro repository serves as the primary local verification gate, running formatting, linting, and type-checking tools in seconds to ensure code quality before commits.

The just check command is the cornerstone quality assurance tool in the macro-inc/macro codebase. It provides developers with a rapid feedback loop that validates changes without requiring a full build. Understanding its implementation and usage helps contributors maintain consistent code standards across the project's Rust and JavaScript/TypeScript components.

What Does just check Do?

According to docs/STYLE_GUIDE.md in the Macro repository, just check operates as the single verification gate for local development. The command orchestrates multiple quality assurance tools designed to complete in seconds while catching formatting drift, lint failures, and type errors.

Automated Code Formatting

The verification process begins by enforcing consistent code style across the entire codebase. It executes rustfmt for Rust source files and biome for JavaScript and TypeScript components. These tools automatically format code to match project-specific style guidelines.

Static Analysis and Linting

The command runs oxlint and ast-grep to detect style violations, potential bugs, and enforce project-specific coding rules. These linters scan the repository for problematic patterns and anti-patterns without executing the actual code.

Fast Type Checking

Rather than compiling the entire project, just check invokes cargo check to perform quick type validation. As documented in CLAUDE.md, this provides "type check without building," offering rapid feedback on type errors while avoiding the overhead of a full compilation.

Running just check in the Macro Repository

To execute the standard verification suite during day-to-day development:

just check

This command is optimized for speed and is sufficient for most iterative development workflows.

Extended Verification with just check full

For comprehensive validation before submitting changes, the repository provides an extended mode:

just check full

This variant adds TypeScript compilation via tsc and the full Clippy lint suite to the standard checks. While slower than the default command, it provides exhaustive verification suitable for pre-merge validation.

Implementation and Configuration

The command logic resides in tooling/just/check.just, which defines the specific tools and their execution order. The docs/STYLE_GUIDE.md explicitly documents this as the "single gate: format + lint + code rules, scoped" for local development workflows.

Summary

• just check is the primary local verification command in the Macro repository, designed to complete in seconds
• It executes formatting tools (rustfmt, biome), linters (oxlint, ast-grep), and type checking (cargo check)
• The command serves as the first line of defense against code quality issues without requiring a full build
• just check full provides extended verification including TypeScript compilation and the complete Clippy suite
• Configuration and tool definitions live in tooling/just/check.just with documentation in docs/STYLE_GUIDE.md

Frequently Asked Questions

What specific tools does just check execute?

The command runs rustfmt and biome for code formatting, oxlint and ast-grep for static analysis and linting, and cargo check for Rust type validation. These tools are orchestrated through the Just command runner as defined in tooling/just/check.just.

How does just check differ from just check full?

The standard command performs fast checks suitable for iterative development, completing in seconds. The full variant adds TypeScript compilation (tsc) and the complete Clippy lint suite, making it appropriate for final verification before merging but significantly slower to execute.

Where is the just check command defined in the Macro codebase?

The implementation resides in tooling/just/check.just, which contains the Just recipe definitions. Documentation explaining its role as the "single gate" appears in docs/STYLE_GUIDE.md, while CLAUDE.md describes it specifically as a shortcut for type checking without building.

Why use just check instead of running individual tools?

Using just check ensures you execute the exact verification sequence configured for the Macro repository. This guarantees consistency with CI requirements and catches issues early without manual tool invocation or the time overhead of a full project compilation.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}