---

name: omnidev description: "Omniscient hyper-elite software engineering command center. Triggers: write code, debug, fix bug, build app, create API, design system, architect, deploy, secure, optimize, refactor, review code, test, CI/CD, Docker, Kubernetes, database, frontend, backend, full-stack, React, Python, TypeScript, Go, Rust, Java, any programming language, any framework, infrastructure, DevOps, SRE, security audit, performance tuning, code review, technical debt, microservices, monolith, serverless, cloud architecture, AWS, GCP, Azure, mobile, web, desktop, CLI tool, library, SDK, API design, GraphQL, REST, gRPC, WebSocket, authentication, authorization, encryption, logging, monitoring, alerting, incident response, disaster recovery, scaling, caching, queuing, debugging production, root cause analysis, profiling, tracing. Produces: production-grade, secure, performant, maintainable code and systems. Enables 10x development velocity with first-pass success."

OmniDev

Mission: Enable 10x development velocity through omniscient software engineering mastery across all languages, frameworks, and domains.

Decision Tree - Start Here

What are you doing?

---

Code Generation

Input: Requirements (natural language or specs)
Output: Production-ready code in /mnt/user-data/outputs/
Success: Passes lint, tests, security scan

Language Selection

Code Quality Gates (ALWAYS)

Copy# Before ANY code is complete:
1. Lint        → Language-specific linter (no warnings)
2. Type check  → mypy/tsc/go vet (strict mode)
3. Test        → pytest/jest/go test (>80% coverage)
4. Security    → bandit/npm audit/gosec (0 high/critical)
5. Format      → black/prettier/gofmt (auto-applied)

Patterns by Domain

API Endpoint (FastAPI example):

Copyfrom fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel, Field

class ItemCreate(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    price: float = Field(..., gt=0)

@app.post("/items", response_model=Item, status_code=201)
async def create_item(item: ItemCreate, db: Session = Depends(get_db)):
    try:
        return crud.create_item(db, item)
    except IntegrityError:
        raise HTTPException(409, "Item exists")

React Component (TypeScript):

Copyinterface Props {
  items: Item[];
  onSelect: (id: string) => void;
}

export const ItemList: React.FC<Props> = ({ items, onSelect }) => {
  const [selected, setSelected] = useState<string | null>(null);
  
  const handleSelect = useCallback((id: string) => {
    setSelected(id);
    onSelect(id);
  }, [onSelect]);

  return (
    <ul role="listbox" aria-label="Items">
      {items.map(item => (
        <li key={item.id} onClick={() => handleSelect(item.id)}>
          {item.name}
        </li>
      ))}
    </ul>
  );
};

---

Debug Protocol

Input: Bug description, error message, or unexpected behavior
Output: Root cause + fix
Success: Issue resolved, regression test added

Debug Decision Tree

Copy1. REPRODUCE → Can you trigger the bug consistently?
   ├─ No  → Add logging, gather more data
   └─ Yes → Continue
   
2. ISOLATE → Where does it fail?
   ├─ Frontend → Browser DevTools, React DevTools
   ├─ API → Request/Response logging, curl testing
   ├─ Database → Query analysis, EXPLAIN
   └─ Infrastructure → Logs, metrics, traces
   
3. HYPOTHESIZE → What could cause this?
   ├─ List 3 most likely causes
   └─ Test each systematically
   
4. FIX → Apply minimal change
   
5. VERIFY → Run tests + manual verification
   
6. PREVENT → Add test covering this case

Common Bug Patterns

Debug Commands

Copy# Python
python -m pdb script.py          # Interactive debugger
python -c "import traceback; traceback.print_exc()"

# Node
node --inspect script.js         # Chrome DevTools debug
DEBUG=* node script.js           # Enable debug logging

# Go
dlv debug ./main.go              # Delve debugger
GODEBUG=gctrace=1 ./app          # GC tracing

# Logs
journalctl -u service -f         # Follow systemd logs
kubectl logs -f pod-name         # K8s pod logs
docker logs -f container         # Docker logs

---

Architecture

Input: Business requirements, constraints, scale expectations
Output: System design document, architecture diagram description
Success: Meets requirements, scalable, maintainable

Architecture Decision Tree

CopySCALE?
├─ <1K users → Monolith + PostgreSQL
├─ 1K-100K   → Modular monolith or simple microservices
├─ 100K-1M   → Microservices + caching + CDN
└─ >1M       → See references/scale.md

TEAM SIZE?
├─ 1-3 devs  → Monolith (always)
├─ 4-10 devs → Modular monolith
└─ >10 devs  → Consider microservices

LATENCY?
├─ <50ms  → Edge computing, caching, CDN
├─ <200ms → Regional deployment
└─ <1s    → Standard architecture

Architecture Patterns

System Design Template

Copy## [System Name]

### Requirements
- Functional: [What it must do]
- Non-functional: [Performance, scale, availability]
- Constraints: [Budget, timeline, team skills]

### High-Level Design
- Components: [List services/modules]
- Data flow: [How data moves]
- Storage: [Database choices]

### API Contracts
- [Endpoint definitions]

### Data Model
- [Entity relationships]

### Failure Modes
- [What can go wrong + mitigations]

---

Infrastructure

Input: Application to deploy, environment requirements
Output: Deployed, monitored, scalable infrastructure
Success: 99.9%+ uptime, <5min deploy, automated rollback

Deployment Decision Tree

CopyWHERE?
├─ Static site     → Vercel/Netlify/Cloudflare Pages
├─ Container app   → K8s/ECS/Cloud Run
├─ Serverless      → Lambda/Cloud Functions
├─ VM needed       → EC2/GCE/Droplet
└─ Edge compute    → Cloudflare Workers/Lambda@Edge

CI/CD?
├─ GitHub      → GitHub Actions
├─ GitLab      → GitLab CI
├─ Self-hosted → Jenkins/Drone
└─ Simple      → scripts/deploy.sh

Docker (Always Use Multi-Stage)

Copy# Build stage
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build

# Production stage
FROM node:20-alpine
WORKDIR /app
RUN addgroup -g 1001 app && adduser -u 1001 -G app -s /bin/sh -D app
COPY --from=builder --chown=app:app /app/dist ./dist
COPY --from=builder --chown=app:app /app/node_modules ./node_modules
USER app
EXPOSE 3000
CMD ["node", "dist/index.js"]

Kubernetes Essentials

CopyapiVersion: apps/v1
kind: Deployment
metadata:
  name: app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: app
  template:
    spec:
      containers:
      - name: app
        image: app:v1.0.0  # NEVER use :latest
        resources:
          requests: { memory: "128Mi", cpu: "100m" }
          limits: { memory: "256Mi", cpu: "500m" }
        livenessProbe:
          httpGet: { path: /health, port: 8080 }
          initialDelaySeconds: 10
        readinessProbe:
          httpGet: { path: /ready, port: 8080 }
        securityContext:
          runAsNonRoot: true
          readOnlyRootFilesystem: true

---

Security

Input: System to secure, compliance requirements
Output: Hardened system, security report
Success: Passes security scan, meets compliance

Security Checklist (ALWAYS)

OWASP Top 10 Quick Reference

---

Optimization

Input: Slow system, performance requirements
Output: Optimized system with metrics
Success: Meets latency/throughput targets

Performance Decision Tree

CopyWHERE IS IT SLOW?
├─ Frontend
│  ├─ Initial load → Bundle size, code splitting
│  ├─ Runtime → React profiler, memoization
│  └─ Network → Caching, CDN, compression
├─ API
│  ├─ Database → Query optimization, indexing
│  ├─ Compute → Algorithm, caching, async
│  └─ Network → Connection pooling, keep-alive
└─ Infrastructure
   ├─ CPU bound → Horizontal scaling, optimize code
   ├─ Memory bound → Reduce allocations, streaming
   └─ I/O bound → Async, batching, caching

Caching Strategy

---

Review Protocol

Input: Code to review (PR/MR link or diff)
Output: Actionable feedback
Success: Issues caught, knowledge shared

Review Checklist

---

Critical Rules

---

References

• references/languages.md - Language-specific patterns for 20+ languages
• references/databases.md - SQL/NoSQL design, optimization, migrations
• references/cloud.md - AWS/GCP/Azure architecture patterns
• references/testing.md - Test strategies, TDD, coverage
• references/scale.md - High-scale architecture patterns