Dependency upgrades can break builds, tests, and runtime behavior. This skill helps plan staged upgrades, compatibility checks, testing, and rollback steps.

Complex failures produce scattered evidence and uncertain fixes. This skill organizes triage, ranked hypotheses, root cause analysis, validation, and prevention.

Complex defects waste time when investigation relies on guesswork. This skill applies reproducible experiments, targeted instrumentation, profiling, and verification to identify root causes.

Domain rules often become scattered across controllers and persistence code. This skill structures them with aggregates, value objects, repositories, and domain events.

Complex domains often produce unclear service boundaries, inconsistent terms, and disputed ownership. This skill creates subdomain maps, context catalogs, glossaries, and documented boundary decisions.

Durable TypeScript services need clear workflow rules and failure handling. This skill guides DBOS workflows, steps, queues, clients, communication, testing, and upgrades.

Reliable Python services need workflows that recover after crashes and retries. This skill gives Claude, Codex, and Claude Code practical DBOS guidance for workflows, steps, queues, clients, and tests.

Reliable Go workflow code is hard to design across crashes, retries, and deployments. This skill gives DBOS patterns for workflows, steps, queues, clients, testing, and upgrades.

Large repositories force coding agents to rediscover structure during every task. DSP stores a queryable dependency graph with stable identities and explicit connection reasons.

Database choices often ignore workload, deployment, and migration constraints. This skill guides selection, schema design, indexing, optimization, and safer changes.

Complex .NET projects require consistent architecture, asynchronous design, performance discipline, and reliable tests. This skill provides focused C# guidance and verifiable implementation steps.

Multi-agent projects often fail because roles, tasks, dependencies, and control flow are unclear. This skill provides practical CrewAI patterns for structured Python workflows.

Pull request descriptions often miss context or reviewer needs. This skill guides Claude, Codex, and Claude Code through branch checks, diff review, draft PR creation, and Sentry-style descriptions.

C systems work can fail through leaks, unchecked calls, and poor portability. This skill guides robust C99/C11 implementation, testing, debugging, and performance validation.

Complex C++ systems can hide ownership, concurrency, and performance problems. This skill applies modern language features, RAII, testing, and profiling practices to produce maintainable solutions.

Integrating Copilot across languages requires careful setup for sessions, tools, authentication, and lifecycle events. This skill provides focused SDK patterns for four supported runtimes.

LLM applications lose useful context across turns and sessions. This skill provides patterns for tiered storage, entity facts, retrieval, consolidation, and user isolation.

Long conversations can exceed token limits and lose important details. This skill provides budgeting, summarization, prioritization, and routing strategies for reliable context assembly.

AI applications lose relevance when context, memory, and retrieval systems are poorly designed. This skill guides context architecture, RAG, knowledge graphs, and multi-agent state management.

New engineering work often starts without clear scope or acceptance criteria. This skill gathers inputs and produces Conductor specs, plans, metadata, and track links.