| name | alien-engineering-collection |
| description | A comprehensive collection of Agent Skills for software engineering excellence. Use when designing systems, reviewing code, debugging failures, designing APIs, building test strategies, optimizing performance, hardening security, or responding to incidents. Activate for any senior engineering task. |
Alien Agent Skills for Engineering
This collection provides structured guidance for senior software engineering across the full development lifecycle — from system design to incident response.
When to Activate
Activate these skills when:
- Designing new systems or evaluating architectural trade-offs
- Conducting or receiving code reviews
- Debugging complex failures or production issues
- Designing APIs or evaluating API contracts
- Building or improving test strategies
- Profiling, benchmarking, or optimizing performance
- Threat modeling or hardening systems against attacks
- Responding to or writing postmortems for incidents
Skill Map
Foundational Design
System Design
Architecture is the set of decisions that are hardest to change later. Good system design means making those decisions explicitly, with known trade-offs, rather than discovering them under load. The CAP theorem, consistency models, and scalability patterns are the vocabulary — the discipline is knowing which trade-off to accept for a given context.
API Design
APIs are contracts. Breaking a contract breaks trust and breaks consumers. Effective API design means designing for the client first, versioning from day one, and treating backwards compatibility as a first-class constraint. REST, GraphQL, and gRPC each make different trade-offs — the choice should be deliberate, not habitual.
Quality Engineering
Code Review
Code review is the highest-leverage quality gate in the development process. A good review catches bugs, enforces architecture, transfers knowledge, and holds the line on complexity. A bad review is a rubber stamp that provides false assurance. The discipline is knowing what to look for and how to communicate it.
Testing Strategy
The test pyramid is a ratio, not a rule. Unit tests are fast and cheap but prove little about integration. E2E tests prove a lot but are slow and brittle. The right mix depends on risk profile, deployment cadence, and system architecture. The goal is confidence per dollar of CI time.
Debugging Methodology
Debugging is hypothesis generation and testing under time pressure. The worst debugging strategy is random mutation — changing things and hoping. The best is systematic: reproduce, isolate, hypothesize, verify. Every debugging session should end with a root cause, not just a fix.
Operational Excellence
Performance Engineering
Measure before you optimize. The most expensive optimization is one that targets the wrong bottleneck. Performance engineering is a discipline of instrumentation, profiling, and hypothesis-driven experimentation — not intuition-based micro-optimization.
Security Engineering
Security is not a feature added at the end — it is a property of the design. Threat modeling, secure defaults, and defense in depth are the foundations. OWASP Top 10 is the minimum floor, not the ceiling.
Incident Response
Every production system will fail. The question is how quickly and cleanly you respond. Good incident response is a practiced discipline: detect, contain, diagnose, resolve, and learn. Postmortems are the learning mechanism — blameless, specific, and action-oriented.
Core Themes
Three themes run through every skill in this collection:
- Explicit trade-offs over hidden defaults — every design choice accepts some trade-off; name it.
- Measure before you act — intuition is a starting point, not a conclusion.
- Systems degrade in predictable ways — learn the failure modes before you encounter them in production.
Integration
Skills in this collection build on and reference each other:
- system-design provides the architectural context for api-design, security-engineering, and performance-engineering
- code-review applies the standards defined in all other skills
- debugging-methodology is used in incident-response and testing-strategy
- testing-strategy informs what to verify in code-review
- incident-response produces the learning that feeds back into system-design
Skill Metadata
Created: 2026-04-10
Author: Alien Agent Skills for Engineering Contributors
Version: 1.0.0
