New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Component Boundary Identifier

by ArabelaTso in ArabelaTso/Skills-4-SE

Identifies boundaries between modules or components in software systems through static code analysis and dependency detection.

Apache-2.0Auto-check passedDevelopment

Install Component Boundary Identifier

skills CLI
$ npx skills add ArabelaTso/Skills-4-SE --skill component-boundary-identifier -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install ArabelaTso/Skills-4-SE component-boundary-identifier --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/ArabelaTso/Skills-4-SE.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/component-boundary-identifier .claude/skills/component-boundary-identifier && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
component-boundary-identifier
GitHub stars
253
Token cost
~2.5k tokens
SKILL.md length
869 words
Files
4 (incl. scripts, references)
Skills in repo
150
Repo updated
First seen
Licence
Apache-2.0

At a glance

Identifies boundaries between modules or components in software systems through static code analysis and dependency detection.

  • Works in 5 steps: Understand the Request → Analyze Project Structure → Identify Boundaries → …
  • Claude needs to analyze software architecture
  • SKILL.md covers Quick Start, What This Skill Does, Analysis Methods and Architectural Patterns, plus 4 more sections
  • Runs Python scripts from its folder; calls python

What it does

Component Boundary Identifier is an agent skill from ArabelaTso/Skills-4-SE. Identifies boundaries between modules or components in software systems through static code analysis and dependency detection. Use when Claude needs to analyze software architecture, identify module boundaries, detect boundary violations, find circular dependencies, or assess component coupling. Supports Python (packages and imports) and Java (packages and dependencies). Trigger when users ask to "identify boundaries", "find component boundaries", "detect boundary violations", "analyze module structure", "check…

Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including scripts and reference files (for example `references/boundary-indicators.md`, `references/violation-patterns.md` and `scripts/analyze_boundaries.py`).

It sits in Development, covering Software architecture. It works with Python and Java. The repository describes itself as: A curated list of 180+ useful Claude Skills for Software Engineering and resources for customizing AI for SE workflows. The licence is Apache-2.0.

When your agent uses it

  • Claude needs to analyze software architecture
  • Identify module boundaries
  • Detect boundary violations
  • Find circular dependencies

Example prompts

  • “identify boundaries”
  • “find component boundaries”
  • “detect boundary violations”
  • “/component-boundary-identifier”

Requirements

  • Python 3

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Understand the Request
  2. Analyze Project Structure
  3. Identify Boundaries
  4. Detect Violations
  5. Report Findings

What it can do on your machine

Read from SKILL.md and the folder at commit 4f38503. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • python

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Component Boundary Identifier loads about 2.5k tokens when it runs, and up to ~6.3k if it reads all its reference files. Until then it costs about 149 tokens; SKILL.md has 869 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~149
When it runs · the whole SKILL.md, loaded when a task matches
~2.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~6.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from ArabelaTso/Skills-4-SE at commit 4f38503, republished under its Apache-2.0 licence (© ArabelaTso). 869 words, ~2,453 tokens.

Download SKILL.mdSave it as .claude/skills/component-boundary-identifier/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
component-boundary-identifier
description
Identifies boundaries between modules or components in software systems through static code analysis and dependency detection. Use when Claude needs to analyze software architecture, identify module boundaries, detect boundary violations, find circular dependencies, or assess component coupling. Supports Python (packages and imports) and Java (packages and dependencies). Trigger when users ask to "identify boundaries", "find component boundaries", "detect boundary violations", "analyze module structure", "check architecture", or "find circular dependencies".

Component Boundary Identifier

Identify and analyze boundaries between software components to ensure proper architectural separation.

Quick Start

When a user requests boundary analysis:

  1. Understand the goal: Identify boundaries, detect violations, or both
  2. Analyze structure: Examine package/module organization and dependencies
  3. Identify boundaries: Determine component boundaries based on structure
  4. Detect violations: Find improper cross-boundary dependencies
  5. Report findings: Present boundaries and violations with severity levels

What This Skill Does

Boundary Identification

Identify component boundaries based on:

  • Package/module structure
  • Namespace organization
  • Architectural patterns (layered, hexagonal, clean)
  • Naming conventions
  • Dependency clusters
Violation Detection

Detect boundary violations including:

  • Upward dependencies (lower layers depending on higher layers)
  • Circular dependencies between components
  • Layer skipping (bypassing intermediate layers)
  • Domain depending on infrastructure
  • Accessing private/internal implementations
  • Concrete type dependencies across boundaries

Analysis Methods

Static Code Analysis

Analyze code structure without execution.

Python:

  • Parse import statements
  • Analyze package structure
  • Identify dependency directions
  • Detect circular imports

Java:

  • Parse import statements
  • Analyze package hierarchy
  • Check access modifiers
  • Identify dependency directions

Script: Use scripts/analyze_boundaries.py for automated Python analysis

Manual Code Review

Review code for boundary patterns.

Process:

  1. Identify top-level packages/modules
  2. Map dependencies between components
  3. Check against architectural rules
  4. Find violations

See: boundary-indicators.md for patterns

Architectural Patterns

Layered Architecture

Layers (top to bottom):

  1. Presentation/API
  2. Application/Service
  3. Domain/Business
  4. Infrastructure/Data

Rules:

  • Dependencies flow downward only
  • No layer skipping
  • No upward dependencies

Violations:

  • Domain imports from API
  • Infrastructure imports from Domain
  • API directly uses Infrastructure (skips Service)
Hexagonal Architecture

Boundaries:

  • Core: Domain logic (center)
  • Ports: Interfaces for external interaction
  • Adapters: Implementations (outside)

Rules:

  • Core has no dependencies on adapters
  • Adapters depend on ports
  • All external access through ports

Violations:

  • Core imports adapter implementations
  • Core depends on frameworks
  • Direct adapter-to-adapter dependencies
Clean Architecture

Boundaries (inside to outside):

  1. Entities (domain models)
  2. Use Cases (business rules)
  3. Interface Adapters
  4. Frameworks & Drivers

Dependency Rule:

  • Dependencies point inward only
  • Inner layers independent of outer layers

Violations:

  • Inner layer imports outer layer
  • Domain depends on UI/API
  • Use cases depend on frameworks

Language-Specific Guidance

Python

Boundary indicators:

  • Top-level packages (domain/, infrastructure/, api/)
  • __init__.py with controlled exports
  • Protocol/ABC definitions

Common violations:

  • Domain imports from infrastructure
  • Circular imports between modules
  • Importing private members (_name)
  • Direct implementation dependencies

See: boundary-indicators.md for details

Java

Boundary indicators:

  • Package hierarchy (com.example.domain, com.example.infrastructure)
  • Access modifiers (public, package-private, private)
  • Interface definitions

Common violations:

  • Domain imports infrastructure packages
  • Accessing package-private from different package
  • Static coupling across boundaries
  • Framework annotations in domain

See: boundary-indicators.md for details

Workflow

1. Understand the Request

Questions to clarify:

  • Identify boundaries or detect violations?
  • Specific architectural pattern in use?
  • Focus on specific components?
  • Known problem areas?
2. Analyze Project Structure

For automated analysis:

bash
python scripts/analyze_boundaries.py <project_directory>

For manual analysis:

  1. List top-level packages/modules
  2. Identify architectural layers
  3. Note naming conventions
  4. Understand intended architecture
3. Identify Boundaries

Look for:

  • Package/module groupings
  • Architectural layer separation
  • Domain vs infrastructure separation
  • API vs business logic separation

Document:

  • Boundary names and purposes
  • Components within each boundary
  • Intended dependency directions
4. Detect Violations

Check for:

  • Upward dependencies
  • Circular dependencies
  • Layer skipping
  • Concrete type dependencies
  • Private/internal access

See: violation-patterns.md for patterns

5. Report Findings

Structure:

IDENTIFIED BOUNDARIES
- boundary1/ (N modules)
- boundary2/ (M modules)

BOUNDARY VIOLATIONS
[CRITICAL] module_a depends on higher layer module_b
[HIGH] Circular dependency: module_c -> module_d -> module_c
[MEDIUM] module_e accesses private implementation

RECOMMENDATIONS
- Fix critical violations first
- Introduce interfaces for concrete dependencies
- Refactor circular dependencies

Violation Severity Levels

Show full SKILL.md (354 more words)Show less
Critical
  • Domain depends on infrastructure
  • Upward dependencies in layered architecture
  • Circular dependencies between major components

Impact: Breaks architectural principles, prevents proper separation

Priority: Fix immediately

High
  • Layer skipping
  • Concrete type dependencies across boundaries
  • Framework coupling in domain

Impact: Reduces flexibility, complicates testing

Priority: Fix soon

Medium
  • Accessing private/internal members
  • Static coupling across boundaries
  • Missing interfaces at boundaries

Impact: Breaks encapsulation, reduces maintainability

Priority: Fix when refactoring

Low
  • Suboptimal package structure
  • Inconsistent naming
  • Missing documentation

Impact: Reduces code clarity

Priority: Fix opportunistically

Detection Patterns

Upward Dependency

Pattern:

python
# domain/services.py
from api.serializers import UserSerializer  # VIOLATION

Detection: Lower layer imports from higher layer

Fix: Move serialization to API layer

Circular Dependency

Pattern:

python
# module_a.py
from module_b import ClassB

# module_b.py
from module_a import ClassA  # VIOLATION

Detection: A imports B, B imports A

Fix: Extract shared interface, use dependency injection

Layer Skipping

Pattern:

python
# api/routes.py
from infrastructure.repositories import UserRepository  # VIOLATION

Detection: API directly uses infrastructure (skips service layer)

Fix: Use service layer as intermediary

Concrete Dependency

Pattern:

python
# domain/services.py
from infrastructure.email import SMTPEmailSender  # VIOLATION

class NotificationService:
    def __init__(self):
        self.sender = SMTPEmailSender()

Detection: Domain depends on concrete infrastructure class

Fix: Depend on interface, inject implementation

Best Practices

Boundary Definition
  • Use clear package/module names
  • Follow architectural patterns consistently
  • Document boundary purposes
  • Establish dependency rules
Dependency Management
  • Depend on interfaces, not implementations
  • Use dependency injection
  • Follow dependency inversion principle
  • Avoid static coupling
Violation Prevention
  • Code reviews focusing on imports
  • Automated dependency analysis in CI/CD
  • Architecture decision records
  • Team training on patterns
Refactoring Strategy
  • Fix critical violations first
  • Introduce interfaces gradually
  • Extract shared code carefully
  • Test after each change

Example Usage Patterns

User: "Identify the component boundaries in this codebase" → Analyze structure, identify boundaries, report findings

User: "Check if there are any boundary violations" → Analyze dependencies, detect violations, report with severity

User: "Is my domain layer properly isolated?" → Check domain dependencies, verify no infrastructure/API imports

User: "Find circular dependencies in the project" → Analyze import graph, identify cycles, report

User: "Does this follow clean architecture?" → Identify layers, check dependency directions, report violations

User: "Why is this module hard to test?" → Analyze dependencies, identify concrete couplings, suggest fixes

Automated Analysis

Use the provided script for Python projects:

bash
python scripts/analyze_boundaries.py /path/to/project

Output:

  • Identified boundaries
  • Boundary violations with severity
  • Circular dependencies
  • Recommendations

Limitations:

  • Python only (for automated analysis)
  • Requires valid Python syntax
  • May miss dynamic imports
  • Heuristic-based layer detection

For Java or manual analysis, follow the workflow using reference patterns.

© ArabelaTso, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (scripts, references) in skills/component-boundary-identifier of ArabelaTso/Skills-4-SE.

  • SKILL.md
  • references/boundary-indicators.md
  • references/violation-patterns.md
  • scripts/analyze_boundaries.py

Open the folder on GitHubat commit 4f38503

Compare with similar skills

Component Boundary Identifier next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Component Boundary Identifier compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Component Boundary Identifier this skillArabelaTso/Skills-4-SE253—~2.5kAutomated safety check: PassApache-2.0
Code Review Skillawesome-skills/code-review-skill2.1k—~2.8kAutomated safety check: NotesMIT
Code Review Excellenceandrew-yangy/gru-ai155—~1.7kAutomated safety check: NotesMIT
Code Graph Mermaid Diagramstrailofbits/skills7.4k1 repos~1.7kAutomated safety check: PassCC-BY-SA-4.0
Senior Architect Toolkitmaslennikov-ig/claude-code-orchestrator-kit2608 repos~1.2kAutomated safety check: NotesCustom licence
Code To Diagramzebbern/claude-code-guide4.7k1 repos~972Automated safety check: PassMIT

Similar skills

  • Code Review Skill

    awesome-skills/code-review-skill

    Provides comprehensive code review guidance for React 19, Vue 3, Angular 17+, Svelte 5, Rust, TypeScript, Java, Java 8, PHP, Ruby, Rails, Python, Django, FastAPI, Go, C/.NET, Kotlin, Swift, Dart…

    2.1k GitHub stars~2.8k tokensUpdated 1 mo ago
    DevelopmentAuto-check: notes

  • Code Review Excellence

    andrew-yangy/gru-ai

    Provides comprehensive code review guidance for React 19, Vue 3, Rust, TypeScript, Java, Python, and C/C++.

    155 GitHub stars~1.7k tokensUpdated 7 mo ago
    DevelopmentAuto-check: notes

  • Code Graph Mermaid Diagrams

    trailofbits/skills

    Official

    Generates Mermaid diagrams from Trailmark code graphs, including call graphs, class hierarchies, module dependency maps, complexity heatmaps and attack surface data flows.

    7.4k GitHub starsUsed in 1 repo~1.7k tokens
    DevelopmentAuto-check passed

  • Senior Architect Toolkit

    maslennikov-ig/claude-code-orchestrator-kit

    Comprehensive software architecture skill for designing scalable, maintainable systems using ReactJS, NextJS, NodeJS, Express, React Native, Swift, Kotlin…

    260 GitHub starsUsed in 8 repos~1.2k tokens
    DevelopmentAuto-check: notes

  • Code To Diagram

    zebbern/claude-code-guide

    Analyze codebases and automatically generate architecture diagrams, flowcharts, and org charts.

    4.7k GitHub starsUsed in 1 repo~972 tokens
    DevelopmentAuto-check passed

  • Git History Bug Audit

    ben-manes/caffeine

    Audits a module by walking its git history commit by commit, tracking unresolved issues forward, and reporting the ones that survive to HEAD as findings.

    18k GitHub stars~3.3k tokensUpdated 3 days ago
    DevelopmentAuto-check passed

More from ArabelaTso/Skills-4-SE

All 150 skills in this repo

  • Framework Migration Assistant

    ArabelaTso/Skills-4-SE

    Automatically migrate Python web applications between frameworks (Flask → FastAPI, Django → FastAPI).

    253 GitHub stars~1.9k tokensUpdated 1 mo ago
    Auto-check passed

  • Metamorphic Test Generator

    ArabelaTso/Skills-4-SE

    Generate test cases using metamorphic testing by applying transformations based on metamorphic properties.

    253 GitHub stars~798 tokensUpdated 1 mo ago
    Auto-check passed

  • Reproduction Trace Instrumenter

    ArabelaTso/Skills-4-SE

    Instruments programs to capture execution traces specifically for reproducing reported bugs, enabling consistent replay and diagnosis of failures.

    253 GitHub stars~2.4k tokensUpdated 1 mo ago
    Auto-check passed

  • Spring Mvc To Boot Migrator

    ArabelaTso/Skills-4-SE

    Automatically migrate Spring MVC applications to Spring Boot.

    253 GitHub stars~2.2k tokensUpdated 1 mo ago
    Auto-check passed

  • State Snapshot Instrumenter

    ArabelaTso/Skills-4-SE

    Instrument programs (Python, C/C++, Java) to capture snapshots of key program states at runtime, including variables, memory, and call stacks.

    253 GitHub stars~2.2k tokensUpdated 1 mo ago
    Auto-check passed

Works with

Categories

Questions about Component Boundary Identifier

What does Component Boundary Identifier do?

Identifies boundaries between modules or components in software systems through static code analysis and dependency detection. Component Boundary Identifier is an agent skill from ArabelaTso/Skills-4-SE. Identifies boundaries between modules or components in software systems through static code analysis and dependency detection.

When should I use Component Boundary Identifier?

Component Boundary Identifier fits situations like: Claude needs to analyze software architecture; identify module boundaries; detect boundary violations; find circular dependencies.

How do I install Component Boundary Identifier in Claude Code?

Run `npx skills add ArabelaTso/Skills-4-SE --skill component-boundary-identifier -a claude-code`. Or copy the skill folder (skills/component-boundary-identifier in ArabelaTso/Skills-4-SE) into .claude/skills/component-boundary-identifier in your project. Claude Code loads it when a task matches its description.

How do I install Component Boundary Identifier in Codex?

Run `npx skills add ArabelaTso/Skills-4-SE --skill component-boundary-identifier -a codex`. Or copy the skill folder (skills/component-boundary-identifier in ArabelaTso/Skills-4-SE) into .agents/skills/component-boundary-identifier in your project. Codex loads it when a task matches its description.

Can I use Component Boundary Identifier in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add ArabelaTso/Skills-4-SE --skill component-boundary-identifier -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/component-boundary-identifier, .gemini/skills/component-boundary-identifier, .github/skills/component-boundary-identifier and .opencode/skills/component-boundary-identifier in your project.

What does Component Boundary Identifier need to run?

Going by SKILL.md and its folder, Component Boundary Identifier needs Python for the scripts in its folder and the command-line tools its instructions call (python). Our summary lists: Python 3.

Does Component Boundary Identifier access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Component Boundary Identifier safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Component Boundary Identifier use?

Component Boundary Identifier is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Component Boundary Identifier use?

About 2.5k tokens (SKILL.md is roughly 9.8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.9k tokens, read only when the agent opens those files.

What are the alternatives to Component Boundary Identifier?

Skills that share tags, products or a category with Component Boundary Identifier: Code Review Skill (awesome-skills/code-review-skill, 2.1k stars), Code Review Excellence (andrew-yangy/gru-ai, 155 stars), Code Graph Mermaid Diagrams (trailofbits/skills, 7.4k stars) and Senior Architect Toolkit (maslennikov-ig/claude-code-orchestrator-kit, 260 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Component Boundary Identifier?

ArabelaTso (a GitHub user) maintains it in ArabelaTso/Skills-4-SE, which has 253 GitHub stars. The repository holds 150 skills in this directory. The repository was last updated on August 21, 2026.

Source: ArabelaTso/Skills-4-SE on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.