review-architecture

Detect and remediate architectural drift across Pinot module boundaries.

6.1k|1.5k|Updated May 19, 2014
One-click install
npx skills add https://github.com/apache/pinot --skill review-architecture-apache
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: review-architecture
Source: https://github.com/apache/pinot/tree/main/.claude/skills/review-architecture
Command: npx skills add https://github.com/apache/pinot --skill review-architecture-apache

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Pinot codebases often drift across module boundaries, creating hard-to-maintain dependencies and invisible coupling. This skill helps reviewers identify architectural missteps such as SPI/impl boundary violations, misplaced logic, and cross-module imports, enabling timely remediation.

Core Features & Use Cases

  • Detects and analyzes architecture violations across Pinot modules (spi/common/core/segment-local, broker/server, controller).
  • Recommends concrete fixes to enforce module boundaries, proper layering, and clean plugin separation.
  • Use Case: During a code review, apply this skill to evaluate a diff that moves a class across module boundaries and produce actionable guidance.

Quick Start

Review the latest diff for module boundary changes and provide actionable recommendations.

Frequently Asked Questions about review-architecture

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I detect architectural drift across module boundaries in Pinot?

To detect architectural drift in Pinot, review code diffs for SPI boundary violations, misplaced logic, and new cross-module imports. Analyzing these changes identifies invisible coupling and hard-to-maintain dependencies across module layers like spi, core, or broker.

When do I need to review SPI boundaries and module design during a code review?

Review SPI boundaries and module design when a diff modifies interfaces, abstract classes, or plugin boundaries. Evaluating these changes is needed when new cross-module dependencies appear, ensuring proper layering and clean plugin separation are maintained.

What's the best way to enforce module boundaries and prevent cross-module imports?

The best way to enforce module boundaries is applying code review principles to analyze diffs across SPI boundaries. This approach produces actionable recommendations to remediate misplaced logic and prevent invisible coupling between modules like controller and server.

Does this architectural review process work for changes moving classes between Pinot modules?

Yes, this architectural review process works for changes moving classes between Pinot modules. By evaluating the diff against module boundaries, it provides concrete fixes to enforce proper layering and clean plugin separation for the specific module transition.

Why does Pinot codebase drift create invisible coupling and hard-to-maintain dependencies?

Pinot codebase drift creates invisible coupling when changes violate SPI or impl boundaries, introducing misplaced logic and cross-module imports. This architectural drift makes dependencies hard-to-maintain by bypassing clean plugin separation and proper module layering.

Can I get actionable recommendations for fixing architecture violations in Pinot?

Yes, you can get actionable recommendations for fixing architecture violations in Pinot. The review process analyzes diffs across SPI boundaries and applies code review principles to recommend concrete fixes that enforce module boundaries and proper layering.