# Review Backend Architecture with Senior Guidance

Backend services can drift into tight coupling, unclear responsibilities, and fragile tests. This skill guides Claude, Codex, and Claude Code through architecture review, refactoring, and implementation decisions.

## Install

```bash
npx skillstore add bikach/backend-architect
```

## Metadata

- - Slug: bikach-backend-architect
- - Version: 1.0.0
- - Author: Bikach
- - GitHub username: Bikach
- - License: MIT
- - Repository: https://github.com/Bikach/skills-claude-code/tree/main/backend-architect
- - Ref: main
- - Supported tools: Claude, Codex, Claude Code
- - Risk level: medium
- - Risk factors: external\_commands
- - Quality score: 73
- - Public page: https://skillstore.pages.dev/skills/bikach-backend-architect
- - Manifest: https://skillstore.pages.dev/api/skills/bikach-backend-architect/manifest

## Capabilities

- Reviews backend code changes for architecture, layering, and dependency direction.
- Applies hexagonal architecture, DDD, and SOLID checklists to feature design.
- Identifies common code smells such as god classes, long methods, and primitive obsession.
- Suggests targeted refactoring steps with priority, impact, and recommended fixes.
- Uses testing, performance, and clean code checklists to improve implementation quality.
- Provides reference structures for ports, adapters, use cases, and bounded contexts.

## Use Cases

- Design a New Backend Feature: Plan bounded contexts, ports, adapters, use cases, and test strategy before implementation starts.
- Review a Pull Request: Check recent changes for SOLID violations, layer leaks, code smells, and missing tests.
- Refactor a Legacy Service: Break down large services, move logic into domain models, and introduce clearer abstractions.

## Prompt Templates

### Review My Backend Change

```
Review the current backend changes for architecture, SOLID principles, code smells, and missing tests. Prioritize issues as P0, P1, or P2.
```

### Design a Feature Structure

```
Design a backend structure for this feature using hexagonal architecture. Identify domain models, use cases, ports, adapters, and test coverage.
```

### Plan a Refactor

```
Analyze this service for god class, feature envy, primitive obsession, long method, and shotgun surgery risks. Propose a staged refactoring plan.
```

### Audit Architecture Boundaries

```
Audit the module boundaries and dependency direction across these backend contexts. Find layer violations, coupling risks, and missing abstractions.
```

## Limitations

- It is focused on backend architecture, not frontend design or infrastructure operations.
- Its examples are conceptual and may need adaptation for each framework or language.
- Bash-based review steps should be scoped to trusted repository commands.
- It does not replace project-specific product, security, or compliance review.

## Best Practices

- Start with the business use case, then define domain models, ports, and adapters.
- Ask for prioritized findings with file locations, impact, and recommended fixes.
- Run only necessary repository commands and review results before applying changes.

## Anti Patterns

- Using the skill as a general shell automation tool instead of an architecture reviewer.
- Requesting broad rewrites before identifying the smallest useful refactoring step.
- Applying DDD or hexagonal architecture mechanically when the service does not need it.

## Security Audit

- - Safe to publish: true
- - Audited at: 2026-06-28T15:13:34.867\+00:00
- - Summary: Static analysis reported many high-risk weak-cryptography and Ruby backtick findings, but reviewed examples show markdown diagrams, prose, paths, and architecture terminology rather than executable cryptographic code or shell execution. No prompt injection, data exfiltration, network behavior, credential harvesting, or malicious intent was found. The remaining risk is medium because the skill allows Bash and recommends command-based review workflows.

## Stats

- - Views: 479
- - Downloads: 13
- - Favorites: 0
- - Popularity score: 0