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)

# 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):

from 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):

interface 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

1. 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

# 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

SCALE?
├─ <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

## [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

WHERE?
├─ 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)

# 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

apiVersion: 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

WHERE 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