pre-generation-arch-check

Detect architectural anti-patterns and separation-of-concerns violations in proposed file changes.

1|Updated May 21, 2026
One-click install
npx skills add https://github.com/hiddink-ai/hiddink-harness --skill pre-generation-arch-check
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: pre-generation-arch-check
Source: https://github.com/hiddink-ai/hiddink-harness/tree/main/templates/skills/pre-generation-arch-check
Command: npx skills add https://github.com/hiddink-ai/hiddink-harness --skill pre-generation-arch-check

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill prevents architectural drift and design violations by detecting anti-patterns like improper separation of concerns or unauthorized file modifications before any code is generated.

Core Features & Use Cases

  • Anti-Pattern Detection: Identifies violations of R006 (separation of concerns) and R010 (orchestrator delegation) rules.
  • Pre-Compile Linting: Validates that agent, skill, and guide modifications follow the established project structure.
  • Use Case: When a developer attempts to modify an agent's core logic while simultaneously editing a skill's configuration, this skill flags the violation to ensure the change is routed through the correct management workflow.

Quick Start

Run the pre-generation-arch-check skill to validate your current task plan against the project architecture rules.

Frequently Asked Questions about pre-generation-arch-check

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

FAQPage Schema
How do I prevent architectural drift before code generation?

To prevent architectural drift before code generation, you can run a pre-generation architecture check to validate proposed file changes against project-wide separation of concerns and orchestration rules. This detects anti-patterns early in the planning phase.

What is separation of concerns in code architecture compliance?

Separation of concerns in code architecture compliance is a rule that prevents overlapping modifications, such as editing an agent's core logic and a skill's configuration simultaneously. Pre-generation linting flags these violations to ensure changes route through the correct workflow.

How do I lint proposed file changes against project structure rules?

You can lint proposed file changes by running a pre-generation architecture check that validates task summaries and file modifications against established agent, skill, and guide directory structures to prevent unauthorized modifications.

Does pre-generation architecture linting work for multi-agent orchestration?

Yes, pre-generation architecture linting works for multi-agent orchestration by validating that orchestrator delegation rules are followed. It checks proposed changes to ensure tasks are routed correctly and structural integrity is maintained across directories.

Why are unauthorized file modifications flagged during the planning phase?

Unauthorized file modifications are flagged during the planning phase to enforce architectural integrity and compliance before any code is generated. This prevents structural violations across agent, skill, and guide directories by ensuring changes follow established workflows.