architecture-patterns
Padrões de arquitetura de software - Decisões OBJETIVAS sobre design de sistemas
Full skill instructions
Esta skill ajuda você a tomar decisões OBJETIVAS sobre arquitetura de software.
┌─────────────────────────────────────────────────────────────┐
│ 🚨 REGRA MAIS IMPORTANTE: SEJA OBJETIVO E ÚTIL │
│ │
│ ❌ NUNCA RESPONDA ASSIM: │
│ "Depende dos requisitos do seu sistema..." │
│ "Cada caso é único..." │
│ "Você precisa avaliar trade-offs..." │
│ │
│ ✅ SEMPRE RESPONDA ASSIM: │
│ "Use monolito. Motivo: você tem <10 devs e <1M users" │
│ "Pattern recomendado: Event Sourcing. Aqui está como..." │
│ "Essa arquitetura está errada. Faça isso em vez disso..." │
│ │
│ DÊ RECOMENDAÇÕES ESPECÍFICAS COM RAZÕES CLARAS. │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ USE MONOLITO QUANDO: │
│ │
│ ✅ Time < 10 desenvolvedores │
│ ✅ Produto ainda está descobrindo product-market fit │
│ ✅ Domínio do negócio ainda está mudando │
│ ✅ Você precisa de velocidade de desenvolvimento │
│ ✅ Não tem expertise em sistemas distribuídos │
│ │
│ EXEMPLOS DE EMPRESAS QUE COMEÇARAM COM MONOLITO: │
│ → Shopify (Ruby monolito até bilhões em GMV) │
│ → Basecamp (ainda é monolito) │
│ → GitHub (monolito por anos) │
│ → Airbnb (começou monolito) │
│ │
│ "If you can't build a well-structured monolith, │
│ what makes you think microservices are the answer?" │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ USE MICROSERVICES QUANDO: │
│ │
│ ✅ Time > 50 desenvolvedores │
│ ✅ Domínios claramente separados e estáveis │
│ ✅ Diferentes partes precisam escalar independentemente │
│ ✅ Times autônomos com ownership claro │
│ ✅ Você tem DevOps/Platform team dedicado │
│ │
│ CUSTOS DOS MICROSERVICES (que ninguém conta): │
│ → Latência de rede entre serviços │
│ → Complexidade de debugging distribuído │
│ → Consistência eventual (transactions distribuídas) │
│ → Infraestrutura: K8s, service mesh, observability │
│ → Overhead operacional: deploy, monitoring de N serviços │
│ │
│ "Don't do microservices unless you have the team │
│ and infrastructure to support them." │
└─────────────────────────────────────────────────────────────┘
FLOWCHART DE DECISÃO:
Quantos devs você tem?
│
├─ < 10 devs → MONOLITO (ponto final)
│
├─ 10-50 devs → MODULAR MONOLITH
│ │
│ └─ Monolito bem estruturado com módulos separados
│ que PODEM virar serviços se necessário
│
└─ > 50 devs → CONSIDERE microservices
│
├─ Tem Platform Team? → Talvez microservices
│
└─ Não tem → Modular monolith
┌─────────────────────────────────────────────────────────────┐
│ CLEAN ARCHITECTURE (Uncle Bob) │
│ │
│ ┌───────────────────────────────────────┐ │
│ │ FRAMEWORKS & DRIVERS │ ← Web, DB, UI │
│ │ ┌───────────────────────────────┐ │ │
│ │ │ INTERFACE ADAPTERS │ │ ← Controllers │
│ │ │ ┌───────────────────────┐ │ │ │
│ │ │ │ USE CASES │ │ │ ← Business rules │
│ │ │ │ ┌───────────────┐ │ │ │ │
│ │ │ │ │ ENTITIES │ │ │ │ ← Domain objects │
│ │ │ │ └───────────────┘ │ │ │ │
│ │ │ └───────────────────────┘ │ │ │
│ │ └───────────────────────────────┘ │ │
│ └───────────────────────────────────────┘ │
│ │
│ REGRA: Dependências apontam para DENTRO │
│ → Entities não conhecem Use Cases │
│ → Use Cases não conhecem Controllers │
│ → Controllers não conhecem Frameworks específicos │
│ │
├─────────────────────────────────────────────────────────────┤
│ QUANDO USAR: │
│ ✅ Aplicações com lógica de negócio complexa │
│ ✅ Quando você quer trocar de framework/DB facilmente │
│ ✅ Projetos de longa duração (> 2 anos) │
│ │
│ QUANDO NÃO USAR: │
│ ❌ CRUDs simples │
│ ❌ MVPs e protótipos │
│ ❌ Time inexperiente (curva de aprendizado) │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ CQRS: SEPARE LEITURAS DE ESCRITAS │
│ │
│ MODELO TRADICIONAL: │
│ [Client] ←→ [API] ←→ [Service] ←→ [Database] │
│ │
│ MODELO CQRS: │
│ │
│ [Client] ─── Commands ──→ [Write Model] ─→ [Write DB] │
│ │ │ │
│ │ ▼ (eventos) │
│ │ [Event Bus] │
│ │ │ │
│ │ ▼ │
│ └─── Queries ────→ [Read Model] ←─ [Read DB] │
│ │
├─────────────────────────────────────────────────────────────┤
│ QUANDO USAR: │
│ ✅ Leituras >> Escritas (90% reads, 10% writes) │
│ ✅ Requisitos de leitura diferentes de escrita │
│ ✅ Performance de leitura é crítica │
│ ✅ Múltiplas views do mesmo dado │
│ │
│ QUANDO NÃO USAR: │
│ ❌ CRUD simples │
│ ❌ Consistência forte necessária │
│ ❌ Time pequeno sem experiência │
│ │
│ EXEMPLO PRÁTICO: │
│ E-commerce: Catálogo de produtos │
│ → Escrita: Admin atualiza produto (raro) │
│ → Leitura: Milhões de pageviews (frequente) │
│ → Read model pode ser denormalizado, cacheado, etc. │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ EVENT SOURCING: ARMAZENE EVENTOS, NÃO ESTADO │
│ │
│ TRADICIONAL: │
│ User { name: "João", email: "[email protected]" } │
│ (só o estado atual) │
│ │
│ EVENT SOURCING: │
│ 1. UserCreated { name: "João", email: "[email protected]" } │
│ 2. EmailChanged { email: "[email protected]" } │
│ 3. NameChanged { name: "João Silva" } │
│ → Estado atual = replay de todos os eventos │
│ │
├─────────────────────────────────────────────────────────────┤
│ VANTAGENS: │
│ ✅ Audit log completo (quem, quando, o quê) │
│ ✅ Pode reconstruir estado em qualquer ponto no tempo │
│ ✅ Debug fácil (replay eventos para reproduzir bug) │
│ ✅ Integração natural com CQRS │
│ │
│ DESVANTAGENS: │
│ ❌ Complexidade muito maior │
│ ❌ Storage cresce infinitamente │
│ ❌ Queries são mais complexas │
│ ❌ Evolução de schema de eventos é difícil │
│ │
├─────────────────────────────────────────────────────────────┤
│ QUANDO USAR: │
│ ✅ Auditoria é requisito legal (financeiro, saúde) │
│ ✅ Precisa de "time travel" (undo/redo) │
│ ✅ Domínio naturalmente baseado em eventos │
│ │
│ QUANDO NÃO USAR (maioria dos casos): │
│ ❌ Você não tem requisito de auditoria │
│ ❌ CRUD é suficiente │
│ ❌ Time não tem experiência com ES │
│ │
│ "Event Sourcing is a very powerful pattern, but it's │
│ also very complex. Don't use it unless you need it." │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ COMUNICAÇÃO SÍNCRONA (REST, gRPC) │
│ │
│ [Service A] ──request──→ [Service B] │
│ ↑ │ │
│ └────── response ────────┘ │
│ │
│ A espera B responder │
│ │
│ USE QUANDO: │
│ ✅ Você PRECISA da resposta imediatamente │
│ ✅ Operações simples e rápidas (<100ms) │
│ ✅ User-facing requests │
│ │
├─────────────────────────────────────────────────────────────┤
│ COMUNICAÇÃO ASSÍNCRONA (Message Queue, Events) │
│ │
│ [Service A] ──event──→ [Queue] ──event──→ [Service B] │
│ │ │
│ └─ continua sem esperar │
│ │
│ A NÃO espera B │
│ │
│ USE QUANDO: │
│ ✅ Operação pode demorar (processamento batch) │
│ ✅ Não precisa de resposta imediata │
│ ✅ Desacoplamento é importante │
│ ✅ Retry automático é necessário │
│ │
├─────────────────────────────────────────────────────────────┤
│ RECOMENDAÇÃO: │
│ │
│ User request → SÍNCRONO (REST/gRPC) │
│ Background jobs → ASSÍNCRONO (Queue) │
│ Entre microservices → ASSÍNCRONO quando possível │
└─────────────────────────────────────────────────────────────┘
QUAL USAR:
┌────────────────┬─────────────────────────────────────────┐
│ TECNOLOGIA │ QUANDO USAR │
├────────────────┼─────────────────────────────────────────┤
│ RabbitMQ │ Workload tradicional, routing complexo │
│ │ Bom para: Tasks, RPC assíncrono │
├────────────────┼─────────────────────────────────────────┤
│ Apache Kafka │ High throughput, event streaming │
│ │ Bom para: Logs, analytics, event store │
├────────────────┼─────────────────────────────────────────┤
│ AWS SQS │ Serverless, managed, simples │
│ │ Bom para: Tarefas simples em AWS │
├────────────────┼─────────────────────────────────────────┤
│ Redis Streams │ Já usa Redis, precisa de speed │
│ │ Bom para: Cache + queue em um │
├────────────────┼─────────────────────────────────────────┤
│ BullMQ (Node) │ App Node.js, já tem Redis │
│ │ Bom para: Background jobs em Node │
└────────────────┴─────────────────────────────────────────┘
REGRA SIMPLES:
→ Task queue simples? → BullMQ/SQS
→ Event streaming? → Kafka
→ Routing complexo? → RabbitMQ
→ Não sabe? → Comece com SQS/BullMQ
┌────────────────┬─────────────────────────────────────────┐
│ TIPO │ QUANDO USAR │
├────────────────┼─────────────────────────────────────────┤
│ PostgreSQL │ DEFAULT. Relacional, full-featured. │
│ │ Use para: 90% dos casos │
├────────────────┼─────────────────────────────────────────┤
│ MongoDB │ Documentos JSON, schema flexível │
│ │ Use para: Conteúdo, catálogos │
├────────────────┼─────────────────────────────────────────┤
│ Redis │ Cache, sessões, filas │
│ │ Use para: Performance, dados efêmeros │
├────────────────┼─────────────────────────────────────────┤
│ Elasticsearch │ Full-text search, analytics │
│ │ Use para: Busca, logs │
├────────────────┼─────────────────────────────────────────┤
│ ClickHouse │ Analytics, time-series │
│ │ Use para: Dashboards, métricas │
└────────────────┴─────────────────────────────────────────┘
REGRA: Se você não sabe, use PostgreSQL.
PostgreSQL pode fazer:
→ Relacional (óbvio)
→ JSON (JSONB)
→ Full-text search (basic)
→ Time-series (com extensões)
→ Vector search (pgvector)
"PostgreSQL is the everything database."
Usuário: "Estou começando uma startup, devo usar microservices?"
Resposta:
NÃO. Use monolito.
RAZÕES:
1. VOCÊ NÃO TEM OS PROBLEMAS QUE MICROSERVICES RESOLVEM
Microservices resolvem:
→ Times grandes (50+ devs) que não conseguem trabalhar junto
→ Partes do sistema que precisam escalar diferentemente
→ Deploys independentes por diferentes times
Você tem:
→ Time pequeno (1-10 pessoas)
→ Domínio ainda em descoberta
→ Necessidade de velocidade, não escala
2. CUSTO VS BENEFÍCIO
Microservices adicionam:
→ Latência de rede entre serviços
→ Complexidade de debugging
→ Infraestrutura (K8s, service mesh, etc.)
→ Overhead operacional
Para uma startup, isso é MORTAL. Você vai gastar
tempo resolvendo problemas de infra em vez de
problemas de negócio.
3. O QUE FAZER EM VEZ DISSO:
a) MONOLITO MODULAR
→ Separe código em módulos/packages
→ Defina interfaces claras entre módulos
→ Isso facilita extrair serviço DEPOIS se precisar
b) ESTRUTURA SUGERIDA:
/src
/modules
/users
- controller.ts
- service.ts
- repository.ts
/orders
- controller.ts
- service.ts
- repository.ts
/payments
...
/shared
- database.ts
- auth.ts
c) TECNOLOGIA:
→ Node.js + Express/Fastify ou
→ Python + FastAPI ou
→ Go + Chi
→ PostgreSQL
→ Redis para cache/sessions
→ Tudo em uma máquina ou container
4. QUANDO MIGRAR PARA MICROSERVICES:
→ Você tem 50+ devs
→ Deploys estão atrasando porque times se bloqueiam
→ Parte específica precisa escalar 10x mais que resto
→ Você tem time de plataforma dedicado
Até lá: MONOLITO.
"If you can't build a well-structured monolith,
what makes you think microservices are the answer?"
1. SEJA OBJETIVO — dê recomendações específicas
2. Monolito primeiro, sempre (até 50 devs)
3. PostgreSQL é o default
4. Simplicidade > elegância arquitetural
5. Não adicione complexidade sem razão clara
6. "You ain't gonna need it" (YAGNI)
7. Escolha boring technology
8. Arquitetura evolui com o time e produto
9. Modular monolith é melhor que microservices ruins
10. Se não sabe explicar por que precisa, não precisa
Esta skill ativa AUTOMATICAMENTE quando:
Accessibility guidelines for VS Code features — covers accessibility help dialogs, accessible views, verbosity settings, accessibility signals, ARIA alerts/status announcements, keyboard navigation, and ARIA labels/roles. Applies to both new interactive UI surfaces and updates to existing feature...
Mermaid diagram creation for flowcharts, sequences, ERDs, and more. Generate diagrams from text in markdown files. Use for documentation, architecture diagrams, and visual representations. Triggers on mermaid, flowchart, sequence diagram, ERD, entity relationship, gantt chart, pie chart, class di...
Guides development of cross-platform desktop apps with Tauri 2, TypeScript, React, and Rust. Use when building Tauri apps, implementing IPC, designing Rust backend or TypeScript/React frontend, when researching or cloning a website (open site, snapshot elements), when verifying local dev or built...
Handle errors as values using fp-ts Either and TaskEither for cleaner, more predictable TypeScript code. Use when implementing error handling patterns with fp-ts.
Gate 0 research phase for pre-dev workflow. Dispatches 3 parallel research agents to gather codebase patterns, external best practices, and framework documentation BEFORE creating PRD/TRD. Outputs research.md with file:line references.
Create and configure Vapi voice AI assistants with models, voices, transcribers, tools, hooks, and advanced settings. Use when building voice agents, phone bots, customer support assistants, or any conversational AI that handles phone or web calls.
Use when working with full stack orchestration full stack feature
Delegiere Aufgaben an OpenAI Codex CLI im Headless-Mode. Nutzt ChatGPT Subscription (KEIN API Key). Nur Workspace-Zugriff, KEIN System-Zugriff. Auto-Accept mit --full-auto. Web-Recherche mit --search.
Generate a full week of social media content for any topic. Outputs platform-optimized posts for Twitter/X, LinkedIn, and Instagram with hashtags and posting times.
Data privacy and regulatory compliance specialist for GDPR, CCPA, HIPAA, and international data protection laws. Use when implementing privacy controls, conducting data protection impact assessments, ensuring regulatory compliance, or managing data subject rights. Expert in consent management, da...
Reviews a task using the TRIPLE protocol, as the review agent.
Define and document the technology stack and architecture decisions for a project. Use when the user needs to choose a tech stack, make architecture decisions, define infrastructure choices, or document technology selections. Triggers on requests like "define the tech stack", "choose technologies...
Generate, edit, and beat-sync AI video with leading models in one workspace.
The world's fastest calendar for remote work
Transform Your Design with AI Designer by ImgCreator.ai
Revolutionizing Video Production with AI-Powered Creativity
Extend an image past the frame and let AI fill the new aspect ratio.
Discover your celebrity doppelgänger with StarByFace!
ChainClarity explains 700+ crypto whitepapers in plain English, with layered summaries, comparisons, research tools, alerts, and a $4.99 Pro plan.
Opus.ai: Revolutionize Your Web Experience