DEV Community: Denis

I Curated 106 Software Design Resources and Ranked What Actually Matters

Denis — Thu, 12 Feb 2026 09:39:50 +0000

Most developers learn design patterns from a textbook, forget them in a week, and never apply them.

I spent years doing the same. Then I decided to fix it — not just for myself, but for everyone stuck in that loop.

I went through hundreds of repositories, articles, books, and tools. I kept only what actually helped me write better code. The result: Awesome Software Design — 106 curated resources across 10 categories.

Here's what I learned in the process.

Software Design ≠ Software Architecture

This was my first big realization. Most people use these terms interchangeably. They shouldn't.

Architecture answers: What do we build? Monolith or microservices? Which cloud? How do services communicate?

Design answers: How do we write the code? Which pattern solves this problem? How do we structure modules? How do we verify our design rules hold?

There's already an awesome-software-architecture list. It covers the high-level stuff well. But when I looked for resources on the code level — patterns with real implementations, ADR templates teams actually use, tools that enforce design rules in CI — there was a gap.

The 5 Categories That Changed How I Code

1. Architecture Decision Records (ADR)

This was the biggest surprise. I'd never heard of ADRs until a year ago. Now I can't imagine working without them.

An ADR is a short document capturing why you made a technical decision. Not what, not how — why.

# ADR-001: Use Event Sourcing for Payment Module

## Status: Accepted

## Context
We need full audit trail for all payment state changes...

## Decision
We will use event sourcing for the payment bounded context...

## Consequences
- Complete audit history without additional logging
- Increased storage requirements
- Team needs training on event sourcing patterns

I found 14 real-world ADR examples — from Kubernetes KEPs to Spotify's ADR practice to Rust RFCs. Reading how top engineering teams document decisions taught me more than any course.

Start here: joelparkerhenderson/architecture-decision-record — templates + examples.

2. Design Verification (Enforce Rules, Don't Just Document Them)

This category barely existed in other lists. It's my favorite.

You can write all the architecture rules you want in Confluence. Nobody reads them. Instead, test your architecture:

// Using phparkitect/arkitect
$rules = Rule::allClasses()
    ->that(new ResideInOneOfTheseNamespaces('App\Domain'))
    ->should(new NotDependsOnTheseNamespaces('App\Infrastructure'))
    ->because('Domain layer must not depend on infrastructure');

// Using TNG/ArchUnit
@ArchTest
static final ArchRule domainMustNotAccessInfra =
    noClasses().that().resideInAPackage("..domain..")
        .should().dependOnClassesThat().resideInAPackage("..infrastructure..");

Your design rules run in CI. Every PR. No exceptions. No "we'll fix it later."

Tools by language:

3. Real-World Architecture Case Studies

Textbooks show you patterns in isolation. Reality is messier. I collected case studies from companies that actually built these systems:

Shopify stayed on a monolith — but deconstructed it into modules. Proof that you don't need microservices.
Discord migrated from Cassandra to ScyllaDB to handle trillions of messages. The engineering post reads like a thriller.
Figma built real-time collaboration with CRDTs. Understanding their trade-offs changed how I think about consistency.
Stripe wrote the definitive guide on API design — backward compatibility at scale.

Reading these is worth more than 10 tutorials.

4. Reference Implementations

The gap between "I understand the pattern" and "I can implement it" is huge. Reference implementations bridge it.

The best ones I found:

ThreeDotsLabs/wild-workouts-go-ddd-example — Clean Architecture + CQRS in Go, with a blog series explaining every decision.
kgrzybek/modular-monolith-with-ddd — The most complete Modular Monolith example I've seen. C#, but the patterns are universal.
CodelyTV/php-ddd-example — DDD + Hexagonal in PHP/Symfony. If you're a PHP developer, start here.

5. The Books That Actually Matter

I've seen lists with 50+ books. Nobody reads 50 architecture books. Here are the ones that changed my thinking:

For understanding complexity: A Philosophy of Software Design by Ousterhout. Short, opinionated, practical.

For domain modeling: Learning Domain-Driven Design by Khononov. Skip the Blue Book if you're starting out — this is more accessible and modern.

For distributed systems: Designing Data-Intensive Applications by Kleppmann. Non-negotiable if you work with data at any scale.

What I Filtered Out

Curating means saying no. I removed:

Unmaintained repos — last commit 3+ years ago
Tutorial collections — "100 design pattern tutorials" with no quality filter
Duplicates — if Refactoring.Guru covers it better, one link is enough
Hype without substance — "microservices solve everything" content
Generic advice — "use SOLID principles" without showing how

The hardest part was cutting resources I personally liked but that didn't add unique value.

The Numbers

Final result:

106 resources across 10 sections
14 ADR examples from real companies
7 design verification tools across 5 languages
10 real-world case studies from Spotify, Netflix, Uber, Discord, and others
11 books — only the ones that earn their page count

What This Taught Me

Design patterns are a language, not a checklist. The value isn't memorizing all 23 GoF patterns. It's being able to say "this is a Strategy problem" and having your team instantly understand.
ADRs are the most underrated practice in software engineering. Every team should document decisions. Future-you will thank present-you.
Architecture tests > architecture documents. If a rule isn't enforced, it doesn't exist.
Read case studies, not just theory. Understanding why Discord moved off Cassandra teaches more about database selection than any comparison chart.
Curating is harder than collecting. Anyone can aggregate 500 links. The value is in the 106 that matter.

The full list is here: Awesome Software Design

If it's useful, a ⭐ helps others find it. If I missed something great, contributions are welcome.

What design resources changed how you write code? I'd love to hear what I should add.

I Curated 120+ Agentic Development Tools So You Don't Have To

Denis — Wed, 11 Feb 2026 10:48:07 +0000

AI coding agents went from "nice autocomplete" to "rewrite my entire module" in under a year. The ecosystem is exploding — new IDEs, terminal agents, MCP servers, frameworks, and evaluation tools ship every week.

I spent weeks mapping this landscape and organized everything into one curated list:

🔗 Awesome Agentic Development

Here's what's inside and why it matters.

The Problem

If you search for "AI coding tools" you'll find dozens of scattered lists, each covering a narrow slice:

MCP server lists that ignore IDEs and frameworks
IDE comparisons that skip terminal agents
Framework lists that don't mention security or testing

No single resource covers the full stack of agentic development — from the editor you write prompts in, to the observability platform tracking your agent's token spend.

That's the gap this list fills.

15 Categories, One List

The list is organized into 15 sections with 120+ curated entries, each with a one-line description and pricing tag (Free / Freemium / Paid / Enterprise / OSS).

🖥️ AI-Enhanced IDEs & Editors

The big players: Cursor, Windsurf, Zed, Kiro, Trae, and more. These aren't just editors with chat — they run multi-step agentic workflows across your codebase.

⌨️ Terminal-Based Coding Agents

For those who live in the terminal: Claude Code, Aider, Gemini CLI, Goose, OpenAI Codex CLI, and others. These tools reason over your entire repo and commit changes directly.

🧩 VS Code Extensions

Cline, Roo Code, GitHub Copilot, Continue, KiloCode, Cody — the extensions turning VS Code into an agentic workspace.

🤖 Agent Frameworks

Split into multi-agent orchestration (AutoGen, CrewAI, LangGraph, Google ADK, Mastra) and lightweight/specialized (PydanticAI, smolagents, Agno). Whether you're building a research pipeline or a simple tool-calling agent, there's a framework here.

🔌 MCP Ecosystem

The Model Context Protocol is becoming the USB-C of AI agents. The list covers:

Directories — where to find MCP servers
Official servers — GitHub, Docker, Brave Search, Filesystem, Git, Slack, PostgreSQL
Clients — Claude Desktop, VS Code, Cursor, Goose

🧠 Context Engineering

This is the section most lists miss entirely. Standards like CLAUDE.md, AGENTS.md, GEMINI.md, .cursorrules, and llms.txt define how agents understand your project. I also included guides from Martin Fowler and GitHub's analysis of 2,500+ AGENTS.md files.

🏠 Local Models & Self-Hosted

Not everything needs an API call. This section covers inference engines (Ollama, vLLM, llama.cpp, LM Studio) and coding-focused models (Qwen3-Coder, Codestral, Devstral, DeepSeek-Coder-V2, StarCoder2).

🎨 Vibe Coding Platforms

The "describe it and ship it" tools: Bolt.new, Lovable, v0, Firebase Studio, Replit Agent, Devin. Great for prototyping, increasingly viable for production.

🔒 Agent Security

Agents executing arbitrary code is a security nightmare nobody talks about enough. This section covers:

OWASP Top 10 for Agentic Applications 2026
Sandboxing — E2B, Firecracker, gVisor
Research — prompt injection to RCE, MCP server security audits

🔧 Agent DevOps & Automation

AI-powered code review (CodeRabbit, CodeAnt AI, Graphite, Qodo) and CI/CD tools like the Claude Code GitHub Action.

📊 Observability & Tracing

Your agent made 47 LLM calls and spent $2.30 on a single task. Now what? Langfuse, LangSmith, Arize Phoenix, Helicone, Portkey, OpenLIT, and W&B Weave help you trace, debug, and optimize.

✅ Testing & Quality

How do you test non-deterministic AI outputs? Tools like promptfoo, DeepEval, Inspect AI, Ragas, and Evalite provide frameworks for evaluating agents systematically.

📏 Benchmarks & Evaluation

SWE-bench, HumanEval, and Aider Polyglot — the standard benchmarks for measuring coding agent performance.

📚 Learning Resources

Anthropic's "Building Effective Agents", DeepLearning.AI courses, LangChain Academy, and communities on Reddit (r/AI_Agents, r/ChatGPTCoding, r/ClaudeCode, r/vibecoding).

Bonus Features

Beyond the main list, the repo includes:

Feature	Description
LLM Provider Matrix	Which tools work with which models (25 tools × 7 providers)
Star Tracker	Live GitHub star badges for every OSS entry
CI/CD	awesome-lint + weekly link checking with lychee
Issue Templates	Report broken links or nominate new tools
GitHub Discussions	Community nominations channel

How It's Different

I looked at every similar list on GitHub before building this. Here's the gap analysis:

Existing List	Categories Covered
awesome-ai-agents (25k+ ⭐)	1 — Frameworks only
awesome-mcp-servers (35k+ ⭐)	1 — MCP only
awesome-vibe-coding (3k+ ⭐)	4 — IDEs, Terminal, Vibe, Learning
awesome-code-ai (2k+ ⭐)	1 — IDEs/Assistants only
awesome-agentic-development	15 — Full stack coverage

Nobody else covers agent security, context engineering, observability, testing, or LLM provider compatibility in a single resource.

Contributing

The list is CC0-licensed and open for contributions:

Nominate a tool → GitHub Discussions
Submit a PR → see contributing.md
Report a broken link → use the issue template

⭐ If this is useful, star the repo — it helps others find it.

What tools are you using for agentic development? Anything missing from the list? Let me know in the comments 👇

Building a Beautiful macOS Cleaner with Python and Rich UI

Denis — Mon, 06 Oct 2025 13:08:36 +0000

Ever wondered how much disk space is hiding in cache folders, old Xcode archives, or forgotten Docker containers? As a macOS developer, I found myself constantly battling with "Storage Almost Full" notifications. Commercial cleaning apps felt like overkill, so I decided to build my own: macOS Cleaner - a powerful, safe, and beautiful console application.

🔗 GitHub: QDenka/MacCleanCLI
⭐ Star if you find it useful!
🐛 Issues & PRs welcome

The Problem

macOS is notorious for accumulating gigabytes of "Other" storage:

System caches that grow indefinitely
Xcode DerivedData eating 10-20GB
Docker images forgotten after projects
Browser caches across Safari, Chrome, Firefox, Brave...
Homebrew package caches
Old node_modules in abandoned projects

I wanted a tool that was:

Safe - Never delete critical system files
Transparent - Show exactly what will be deleted
Beautiful - Console doesn't mean ugly
Smart - Categorize and prioritize cleaning targets
Fast - Multi-threaded scanning and cleaning

The Solution: Category-Based Architecture

The core design decision was organizing everything around FileCategory enum:

class FileCategory(Enum):
    """Categories of files that can be cleaned."""
    SYSTEM_CACHE = auto()
    USER_CACHE = auto()
    BROWSER_CACHE = auto()
    XCODE_DERIVED_DATA = auto()
    XCODE_ARCHIVES = auto()
    DOCKER_DATA = auto()
    HOMEBREW_CACHE = auto()
    NODE_MODULES = auto()
    PYTHON_CACHE = auto()
    TEMPORARY_FILES = auto()
    LOG_FILES = auto()
    DOWNLOADS = auto()
    TRASH = auto()
    # ... and more

Each category has:

Predefined scan paths - Where to look for files
Cleaning priority - HIGH, MEDIUM, LOW, OPTIONAL
Safety rules - What's protected

Technical Deep Dive

1. Multi-Threaded Scanning with ThreadPoolExecutor

Scanning hundreds of thousands of files can be slow. The solution? Parallel processing:

class SystemScanner:
    def scan(self, categories: Optional[List[FileCategory]] = None) -> ScanResult:
        with ThreadPoolExecutor(max_workers=self.config.max_workers) as executor:
            futures = {}

            for category in categories_to_scan:
                future = executor.submit(self._scan_category, category)
                futures[future] = category

            for future in as_completed(futures):
                category = futures[future]
                result = future.result()
                scan_result.add_category_result(result)

Result: ~500-1000 files/second scan speed on typical macOS systems

2. Type-Safe Data Models with Dataclasses

Using Python 3.10+ dataclasses for clean, maintainable code:

@dataclass
class FileInfo:
    """Information about a file."""
    path: Path
    size: int
    modified_time: datetime
    accessed_time: datetime
    category: FileCategory
    priority: CleaningPriority
    is_safe_to_delete: bool = True

    @property
    def size_mb(self) -> float:
        return self.size / (1024 * 1024)

    @property
    def age_days(self) -> int:
        return (datetime.now() - self.modified_time).days

3. Safety-First Design

Multiple layers of protection prevent catastrophic mistakes:

# Protected paths that are NEVER touched
self.protected_paths = {
    Path("/System"),
    Path("/Library/System"),
    Path("/private/var/db"),
    Path("/usr/bin"),
    Path("/usr/sbin"),
}

# Protected file extensions
protected_extensions = {".dmg", ".pkg", ".app"}

# Always confirm before deletion
if not dry_run:
    confirm = input("Proceed with deletion? [y/N]: ")
    if confirm.lower() != 'y':
        return

Backup System: Optional automatic backup before deletion with configurable retention:

# Backups stored with timestamps
~/.macos-cleaner/backups/2024-10-06_170000/
├── Caches/
└── manifest.json

4. Beautiful Console UI with Rich

The Rich library transforms console output:

from rich.console import Console
from rich.table import Table
from rich.progress import Progress, SpinnerColumn, BarColumn

console = Console()

# Create beautiful tables
table = Table(title="Scan Results", show_header=True)
table.add_column("Category", style="cyan")
table.add_column("Files", justify="right", style="green")
table.add_column("Size", justify="right", style="yellow")

for category, result in scan_result.categories.items():
    table.add_row(
        category.name,
        f"{result.file_count:,}",
        f"{result.total_size_gb:.2f} GB"
    )

console.print(table)

5. New Feature: File Preview with Pagination

One of the latest additions - users can preview exactly what will be deleted:

def show_file_details(files: List[FileInfo], batch_size: int = 20):
    """Show detailed file list with pagination."""
    for i in range(0, len(files), batch_size):
        batch = files[i:i + batch_size]

        panel = Panel(
            self._create_file_list_table(batch),
            title=f"📁 Files {i+1}-{min(i+batch_size, len(files))} of {len(files)}",
            border_style="blue"
        )

        console.print(panel)

        if i + batch_size < len(files):
            if not Confirm.ask("Continue to next page?", default=True):
                break

Developer-Focused Categories ⚡

As developers, we accumulate specific types of bloat:

Xcode

FileCategory.XCODE_DERIVED_DATA: [
    ~/Library/Developer/Xcode/DerivedData
]
# Often 10-20GB of build artifacts

Docker

FileCategory.DOCKER_DATA: [
    ~/.docker,
    ~/Library/Containers/com.docker.docker
]
# Unused containers, images, volumes

Node.js

FileCategory.NODE_MODULES: [
    # Recursively find all node_modules
]
# Old project dependencies

Homebrew

FileCategory.HOMEBREW_CACHE: [
    ~/Library/Caches/Homebrew,
    /usr/local/Homebrew/Library/Homebrew/vendor/cache
]

Testing Strategy

87 tests with 41% coverage, focusing on critical paths:

# tests/test_scanner.py
def test_scan_user_cache(scanner):
    """Test user cache scanning."""
    cache_dir = Path.home() / "Library" / "Caches"

    result = scanner._scan_cache_files(
        FileCategory.USER_CACHE,
        [cache_dir]
    )

    assert result.category == FileCategory.USER_CACHE
    assert result.file_count >= 0
    assert all(f.category == FileCategory.USER_CACHE for f in result.files)

# Run tests
pytest --cov=. --cov-report=term-missing

# Coverage by module
core/scanner.py      87%
core/cleaner.py      76%
models/              92%

Installation & Usage

# Quick install
git clone https://github.com/QDenka/MacCleanCLI.git
cd MacCleanCLI
pip install -e .

# Run interactive mode
macos-cleaner

# Or use the short alias
mclean

# Command-line options
macos-cleaner --scan-only         # Preview only
macos-cleaner --auto              # Auto-clean recommended
macos-cleaner --dry-run --verbose # Safe preview

Architecture Highlights

Clean Separation of Concerns:

MacCleanCLI/
├── core/           # Business logic
│   ├── scanner.py  # Multi-threaded scanning
│   ├── cleaner.py  # Safe deletion
│   └── optimizer.py # System optimizations
├── models/         # Type-safe data structures
│   └── scan_result.py
├── ui/             # Rich-based interface
│   ├── interface.py
│   └── components.py
└── utils/          # Configuration, logging, backup

SOLID Principles:

Single Responsibility: Each class has one job
Open/Closed: Easy to add new categories
Liskov Substitution: Dataclass inheritance
Interface Segregation: Minimal dependencies
Dependency Inversion: Config-driven behavior

Performance Benchmarks

On a typical macOS system:

Scan Speed: 500-1000 files/second
Memory Usage: 50-100 MB during scan
Clean Speed: 200-400 files/second
Thread Count: Configurable (default: 4 workers)

What I Learned

Rich is amazing - Seriously transforms CLI UX
Safety is paramount - Multiple protection layers are essential
Dataclasses rock - Type safety with minimal boilerplate
ThreadPoolExecutor - Simple parallel processing
Testing file operations - Use temp directories and mocks
macOS paths are complex - Safari has 5+ cache locations!

Future Roadmap

📊 Visual reports - HTML/PDF scan summaries
🔄 Scheduled cleaning - LaunchDaemon integration
📱 iOS simulator cleanup - Support iOS DerivedData
🌍 Localization - Multi-language support
🔌 Plugin system - Custom cleaning categories
📈 Historical tracking - Storage trends over time

Try It Yourself!

The project is fully open-source under MIT license:

🔗 GitHub: QDenka/MacCleanCLI
⭐ Star if you find it useful!
🐛 Issues & PRs welcome

Key Takeaways

If you're building a CLI tool, consider:

Use Rich for beautiful, modern console UI
Design around clear abstractions (categories, priorities)
Implement safety by default (dry-run, backups, protection)
Leverage parallel processing for I/O-heavy operations
Use dataclasses for type-safe, maintainable code
Test thoroughly, especially file operations

What's your experience with building CLI tools? Have you tried any interesting libraries for console UI? Drop a comment below! 👇

Built with ❤️ for macOS developers. If this saved your disk space, consider giving it a ⭐ on GitHub!

I Made a Free Alternative to CleanMyMac in 200 Lines of Python

Denis — Wed, 11 Jun 2025 06:46:18 +0000

TL;DR

I got tired of "disk full" warnings and $90 cleaning apps, so I built MacCleanCLI - a free, open-source terminal tool that safely cleans your Mac.

The Problem 😤

My 256GB MacBook: "Your disk is almost full"

Me: Checks CleanMyMac price... $89.95

Also me: "I can build this"

The Solution 🎉

# Install
brew in future

git clone https://github.com/qdenka/MacCleanCLI.git
cd MacCleanCLI
pip install -e .
python main.py

# Run
mclean

What It Cleans 🧹

System & browser caches
Temp files & old logs
Downloads folder cruft
Duplicate files
App leftovers
Much more!

Key Features ✨

# Safe by design
PROTECTED_PATHS = ['/System', '/Library/Extensions', '/usr']

# Beautiful UI with Rich
from rich.console import Console
from rich.progress import Progress

# Multi-threaded for speed
with ThreadPoolExecutor(max_workers=4) as executor:
    # Scan all the things!

Results 📊

Before: 12GB free space 😱
After: 47GB free space 🎉
Time: 2 minutes
Cost: $0

Why It's Different 🌟

Feature	MacCleanCLI	CleanMyMac
Price	Free	$89.95
Open Source	✅	❌
Privacy	100% Local	Cloud Features
Terminal-Native	✅	❌
Customizable	✅	Limited

Try It Now! 🚀

# See it in action
git clone https://github.com/QDenka/MacCleanCLI
cd MacCleanCLI
python main.py --scan-only

Like it? Star it on GitHub ⭐

Questions? Open an issue!

Want to help? PRs welcome!

What tools have you built to solve your own problems? Share in the comments! 👇

Introducing PHPArchitectureGuardian: Static Analysis for Architecture Compliance

Denis — Thu, 15 May 2025 07:17:56 +0000

“Good architecture is invisible; bad architecture haunts you every day.”

Maintaining a large PHP codebase can feel like herding cats: as features multiply, architectural boundaries blur, and subtle design violations creep in. We built PHPArchitectureGuardian because we faced the same pain:

🐛 Undetected Coupling between your Domain and Infrastructure layers
🔄 Controllers importing Persistence classes directly
📦 Missing abstractions leading to spaghetti dependencies

I am spent countless hours refactoring legacy projects to fix these issues. Every sprint, we’d discover new violations—often too late, when debugging production incidents. We realized we needed a tool that:

Automates enforcement of architecture rules
Integrates seamlessly into local workflows and CI pipelines
Grows with your codebase, adapting to your own conventions

Thus, PHPArchitectureGuardian was born: an open-source, Composer-friendly static analyzer that codifies your architecture as code.

🚀 From Idea to Implementation

The Spark While auditing a mission-critical DDD project, we saw dozens of PRs where domain classes referred to framework code. We asked ourselves: “Why not catch this at build time?”
First Prototype We sketched a minimal RuleInterface and a CLI harness. In under a week, we could flag any PHP file violating a simple namespace dependency rule.
Iterative Growth Over the next months we added:
- A ConfigLoader to merge user settings with sane defaults
- Analyzer classes for DDD, Clean, and Hexagonal patterns
- A ConsoleReporter with colorized severity levels

🎯 What Sets PHPArchitectureGuardian Apart

🔑 Key Differentiator	🛠️ How It Helps You
Multiple Built-In Patterns	Enforce DDD, Clean, Hexagonal out of the box
Extensible Rule Engine	Add custom corporate or project-specific rules
Zero Runtime Overhead	Pure static analysis—no performance hit
CI-Friendly	Exit codes and rich console output for pipelines
PHP-Native Config	No YAML or JSON—customize in `.architecture-guardian.php`
Composer-Installed	Just `composer require --dev ...` and go!

🛠️ Deep Dive: How It Works

File Discovery A FileSystem utility locates all .php files under your chosen path, excluding /vendor/, /tests/, and any patterns you configure.
Rule Execution Each analyzer (e.g. DDDAnalyzer) registers a set of RuleInterface implementations:
- DomainLayerRule ensures Domain does not depend on Application or Infrastructure.
- ApplicationLayerRule ensures Application only depends on Domain and itself.
- InfrastructureLayerRule verifies that Infrastructure implements domain interfaces but never leaks domain code upward.
Violation Collection Violations are collected into a ViolationCollection, carrying file paths, messages, and severity levels.
Report Generation The default ConsoleReporter formats and colorizes output. Want JSON? Build your own ReporterInterface and pass it via CLI options.

# Run DDD analysis on src/, show only warnings and above
vendor/bin/php-architecture-guardian --path=src --analyzer=ddd --min-severity=3

🔧 Getting Started in 3 Steps

Install

composer require --dev qdenka/php-architecture-guardian

Configure Copy the example and customize namespaces:

cp vendor/qdenka/php-architecture-guardian/.architecture-guardian.php.example .architecture-guardian.php

Analyze

vendor/bin/php-architecture-guardian --path=src

You’ll instantly see violations and can block merges until your architecture is pristine.

📈 Proven ROI

Teams using PHPArchitectureGuardian report:

🔍 50% fewer architectural bugs in production
⏱ 30% faster code reviews—no more manual layer-violation checks
🤝 Aligns new hires with your architecture from day one

🤝 Join the Community

We believe in open collaboration. If you’ve ever wished to:

✔️ Enforce custom naming conventions
✔️ Plug in additional analysis passes (e.g. performance or security)
✔️ Integrate with Git hooks or other CI platforms

…then PHPArchitectureGuardian is for you.

⭐️ Star us on GitHub
🐛 Report bugs or enhancement requests
📥 Submit pull requests—every contribution is appreciated!

📝 Contributing & Support

See our CONTRIBUTING.md for guidelines, and join the conversation on Slack or your favorite PHP community forum.

📜 License

Released under MIT License. Use, modify, and share freely.

Ready to keep your architecture rock-solid?
Install PHPArchitectureGuardian today and never let a rogue dependency slip by again!