Problem-solving strategies for continuity in real analysis

Problem-solving strategies for limits in real analysis

MCP server registry, auto-discovery, configuration, custom server development guide

n8n otomasyon workflow'lari. Webhook, cron trigger, API entegrasyon, CI/CD otomasyon.

Projeye girdiginde tech stack'i tespit et, uygun skill ve agent'lari aktive et. Kullanim: /project-detect

Codebase'i derinlemesine anla. Onboarding, architecture discovery, dependency mapping.

Embedding strategies, ANN algorithms, hybrid search, RAG chunking strategies, and reranking for semantic search and retrieval.

Facilitates conversational discovery to create Architectural Decision Records (ADRs) for functional requirements covering CLI, REST/HTTP APIs, or both. Use when the user wants to document command-line or HTTP service architecture, capture functional requirements, create ADRs for CLI or API projects, or design interfaces with documented decisions. Part of the skills-for-java project

Guide incident response from detection to post-mortem using SRE principles, severity classification, on-call management, blameless culture, and communication protocols. Use when setting up incident processes, designing escalation policies, or conducting post-mortems.

Implements feedback and notification systems including toasts, alerts, modals, progress indicators, and error states. Use when communicating system state, displaying messages, confirming actions, or showing errors.

Apply and enforce cloud resource tagging strategies across AWS, Azure, GCP, and Kubernetes for cost allocation, ownership tracking, compliance, and automation. Use when implementing cloud governance, optimizing costs, or automating infrastructure management.

Managing secrets (API keys, database credentials, certificates) with Vault, cloud providers, and Kubernetes. Use when storing sensitive data, rotating credentials, syncing secrets to Kubernetes, implementing dynamic secrets, or scanning code for leaked secrets.

Authentication, authorization, and API security implementation. Use when building user systems, protecting APIs, or implementing access control. Covers OAuth 2.1/OIDC, JWT patterns, sessions, Passkeys/WebAuthn, RBAC/ABAC/ReBAC, policy engines (OPA, Casbin, SpiceDB), managed auth (Clerk, Auth0), self-hosted (Keycloak, Ory), and API security best practices.

Async communication patterns using message brokers and task queues. Use when building event-driven systems, background job processing, or service decoupling. Covers Kafka (event streaming), RabbitMQ (complex routing), NATS (cloud-native), Redis Streams, Celery (Python), BullMQ (TypeScript), Temporal (workflows), and event sourcing patterns.

Vector database implementation for AI/ML applications, semantic search, and RAG systems. Use when building chatbots, search engines, recommendation systems, or similarity-based retrieval. Covers Qdrant (primary), Pinecone, Milvus, pgvector, Chroma, embedding generation (OpenAI, Voyage, Cohere), chunking strategies, and hybrid search patterns.

Managing cloud infrastructure using declarative and imperative IaC tools. Use when provisioning cloud resources (Terraform/OpenTofu for multi-cloud, Pulumi for developer-centric workflows, AWS CDK for AWS-native infrastructure), designing reusable modules, implementing state management patterns, or establishing infrastructure deployment workflows.

>

>

>

AgentOps is built out of skills. A good first contribution is not "make a huge framework." It is "teach the system one reusable intent."

Reads raw `.agents/` artifacts and compiles them into a structured, interlinked

> **Quick Ref:** Execute every open issue in an epic via wave-based workers using `spawn_agent`, `wait_agent`, `send_input`, and `close_agent`. Output: closed issues + final validation.

> **Quick Ref:** One command, full lifecycle. `$discovery` → `$crank` → `$validation`. Thin wrapper that delegates to phase orchestrators.

Source of truth: `docs/contracts/codex-skill-api.md`

Spawn isolated agents to execute tasks in parallel with Codex session agents. Fresh context per agent.

> **Quick Ref:** One command to set up the full AgentOps product layer. Progressive — bare repos get everything, existing repos fill gaps only.

> **Quick Ref:** 4-phase investigation (Root Cause → Pattern → Hypothesis → Fix). Output: `.agents/research/YYYY-MM-DD-bug-*.md`

> **Quick Ref:** Autonomous epic execution. `/swarm` for each wave with runtime-native spawning. Output: closed issues + phase-2 handoff for `/validation`.

> Quick Ref: `/deps audit` | `/deps update [--major|--minor|--patch]` | `/deps vuln` | `/deps license`

> **Quick Ref:** Validates that a proposed goal aligns with the product's strategic direction before discovery begins major work. Council-gated with `--preset=product`.

**YOU MUST EXECUTE THIS WORKFLOW. Do not just describe it.**

'Create structured handoff for session continuation. Triggers: handoff, pause, save context, end session, pick up later, continue later.'

> **Quick Ref:** Execute single issue end-to-end. Output: code changes + commit + closed issue.

> **Quick Ref:** Decompose goal into trackable issues with waves. Output: `.agents/plans/*.md` + bd issues.

Trace knowledge artifact lineage to sources.

> **One job:** Tell a new user what AgentOps does and what to do first. Fast.

'Deep codebase exploration. Triggers: research, explore, investigate, understand, deep dive, current state.'

Author and manage holdout scenarios for behavioral validation. Scenarios are stored outside the codebase in .agents/holdout/ where implementing agents cannot see them. Triggers: scenario, holdout, behavioral scenario, create scenario, list scenarios.

> **Purpose:** Run repeatable security checks across code, scripts, hooks, and release gates.

Spawn isolated agents to execute tasks in parallel. Fresh context per agent (Ralph Wiggum pattern).

> **Quick Ref:** Trace design decisions through CASS sessions, handoffs, git, and artifacts. Output: `.agents/research/YYYY-MM-DD-trace-*.md`

> **Purpose:** Is this code ready to ship?

Research a codebase and create architectural documentation describing how features or systems work. Use when the user asks to: (1) Document how a feature works, (2) Create an architecture overview, (3) Explain code structure for onboarding or knowledge transfer, (4) Research and describe a system's design. Produces markdown documents with Mermaid diagrams and stable code references suitable for humans and AI agents.

Guidance for managing R package lifecycle according to tidyverse principles using the lifecycle package. Use when: (1) Setting up lifecycle infrastructure in a package, (2) Deprecating functions or arguments, (3) Renaming functions or arguments, (4) Superseding functions, (5) Marking functions as experimental, (6) Understanding lifecycle stages (stable, experimental, deprecated, superseded), or (7) Writing deprecation helpers for complex scenarios.

Interactive briefing of a plan file — explains reasoning, schema decisions, component choices. Use when developers need to understand a plan before approving.

For standard implementation patterns, always check official guides first:

Model Context Protocol (MCP) enables Claude Code plugins to integrate with external services and APIs by providing structured tool access. Use MCP integration to expose external service capabilities a

For fix goals: reproduce the failure BEFORE work, verify resolution AFTER.

This skill guides the creation of effective skills. For conceptual background, structure details, and writing best practices, read [references/best-practices.md](references/best-practices.md).

Orchestrate Jira workflows end-to-end. Use when building stories with approvals, transitioning items through lifecycle states, or syncing task completion with Jira.