Skip to content

nanaagyei/noetherkin / skills/resume-evidence

resume-evidence

Verified

Derive truthful resume evidence from verified Noetherkin records with assistance and simulation qualifiers. Use for evidence inventories and draft bullets, not credentials or invented impact.

FileKindSize
SKILL.mdskill md1.9 KB
assets/proposal.mdmarkdown2.0 KB
references/FOUNDATION_V1.mdmarkdown5.4 KB
references/OPEN_QUESTIONS.mdmarkdown3.5 KB
references/PROJECT_CHARTER.mdmarkdown6.4 KB
references/apprenticeship-config.schema.jsonconfig3.0 KB
references/architectural-invariants.mdmarkdown2.3 KB
references/assessment.schema.jsonconfig5.0 KB
references/assistance-model.mdmarkdown4.0 KB
references/attention-advisory.schema.jsonconfig3.8 KB
references/bundle.jsonconfig12.0 KB
references/cli.mdmarkdown18.6 KB
references/competencies.yamlconfig37.7 KB
references/competency-model.mdmarkdown5.0 KB
references/competency-state.schema.jsonconfig3.4 KB
references/conformance.mdmarkdown22.0 KB
references/contract-README.mdmarkdown7.0 KB
references/contract-performance-review.mdmarkdown1.5 KB
references/contract-resume-evidence.mdmarkdown2.0 KB
references/contract-team-lead.mdmarkdown2.8 KB
references/current-project.schema.jsonconfig2.3 KB
references/current-track.schema.jsonconfig1.5 KB
references/evidence-model.mdmarkdown4.1 KB
references/evidence.schema.jsonconfig10.3 KB
references/forge.schema.jsonconfig9.5 KB
references/index.mdmarkdown3.6 KB
references/judgment-validity.mdmarkdown6.6 KB
references/learner-profile.schema.jsonconfig1.5 KB
references/leveling-framework.mdmarkdown3.4 KB
references/levels.yamlconfig8.0 KB
references/overview.mdmarkdown2.9 KB
references/permissions-model.mdmarkdown6.7 KB
references/project.schema.jsonconfig9.4 KB
references/proposals.mdmarkdown4.2 KB
references/review-model.mdmarkdown7.2 KB
references/review.schema.jsonconfig13.0 KB
references/runtime.mdmarkdown7.8 KB
references/selection-model.mdmarkdown6.2 KB
references/simulation-lifecycle.mdmarkdown8.0 KB
references/state-model.mdmarkdown13.7 KB
references/task.schema.jsonconfig13.8 KB
references/track.schema.jsonconfig1.3 KB

references/competencies.yaml

View on GitHub
{
  "schema_version": "2.0",
  "catalog_version": "4.0",
  "competencies": [
    {
      "id": "core.codebase-navigation",
      "domain": "core",
      "name": "codebase navigation",
      "observable_behavior": "Trace an unfamiliar request to source and explain component boundaries.",
      "required_core": true
    },
    {
      "id": "core.implementation",
      "domain": "core",
      "name": "implementation",
      "observable_behavior": "Implement a scoped change and explain correctness and failure behavior.",
      "required_core": true,
      "prerequisites": [
        "core.codebase-navigation"
      ]
    },
    {
      "id": "core.debugging",
      "domain": "core",
      "name": "debugging",
      "observable_behavior": "Form and test causal hypotheses against a reproducible failure.",
      "required_core": true,
      "prerequisites": [
        "core.codebase-navigation",
        "core.testing"
      ]
    },
    {
      "id": "core.testing",
      "domain": "core",
      "name": "testing",
      "observable_behavior": "Choose tests that expose plausible defects and explain their limits.",
      "required_core": true,
      "prerequisites": [
        "core.codebase-navigation"
      ]
    },
    {
      "id": "core.technical-communication",
      "domain": "core",
      "name": "technical communication",
      "observable_behavior": "Explain decisions with artifacts, audience context and unresolved uncertainty.",
      "required_core": true
    },
    {
      "id": "core.ownership",
      "domain": "core",
      "name": "ownership",
      "observable_behavior": "Follow work through validation and communicate risks and unfinished obligations.",
      "required_core": true,
      "prerequisites": [
        "core.implementation",
        "core.testing"
      ],
      "encompasses": [
        "core.technical-communication"
      ]
    },
    {
      "id": "core.git",
      "domain": "core",
      "name": "git",
      "observable_behavior": "Create reviewable history and safely resolve conflicting changes.",
      "required_core": true
    },
    {
      "id": "design.api-design",
      "domain": "design",
      "name": "api design",
      "observable_behavior": "Define API behavior including errors and compatibility.",
      "required_core": false,
      "prerequisites": [
        "backend.http-api"
      ]
    },
    {
      "id": "design.abstraction",
      "domain": "design",
      "name": "abstraction",
      "observable_behavior": "Choose a boundary and defend its cost against a simpler alternative.",
      "required_core": false
    },
    {
      "id": "design.data-modeling",
      "domain": "design",
      "name": "data modeling",
      "observable_behavior": "Model identity, constraints and evolution of persisted data.",
      "required_core": false,
      "prerequisites": [
        "backend.databases"
      ]
    },
    {
      "id": "design.system-design",
      "domain": "design",
      "name": "system design",
      "observable_behavior": "Decompose a system using workload and failure assumptions.",
      "required_core": false
    },
    {
      "id": "design.architecture",
      "domain": "design",
      "name": "architecture",
      "observable_behavior": "Explain system boundaries and plan changes across them.",
      "required_core": false
    },
    {
      "id": "design.tradeoff-analysis",
      "domain": "design",
      "name": "tradeoff analysis",
      "observable_behavior": "Compare concrete alternatives against stated constraints.",
      "required_core": false
    },
    {
      "id": "backend.http-api",
      "domain": "backend",
      "name": "http api",
      "observable_behavior": "Trace HTTP requests including status, headers and failure paths.",
      "required_core": false,
      "prerequisites": [
        "core.codebase-navigation"
      ]
    },
    {
      "id": "backend.databases",
      "domain": "backend",
      "name": "databases",
      "observable_behavior": "Explain query behavior, indexes and transactional boundaries.",
      "required_core": false,
      "prerequisites": [
        "core.codebase-navigation"
      ]
    },
    {
      "id": "backend.caching",
      "domain": "backend",
      "name": "caching",
      "observable_behavior": "Choose invalidation and freshness rules and test stale data behavior.",
      "required_core": false
    },
    {
      "id": "backend.authentication-authorization",
      "domain": "backend",
      "name": "authentication authorization",
      "observable_behavior": "Distinguish identity verification from permission checks and test denial paths.",
      "required_core": false,
      "prerequisites": [
        "backend.http-api",
        "core.testing"
      ]
    },
    {
      "id": "backend.concurrency",
      "domain": "backend",
      "name": "concurrency",
      "observable_behavior": "Identify shared state and test ordering and race assumptions.",
      "required_core": false,
      "prerequisites": [
        "core.debugging",
        "core.testing"
      ]
    },
    {
      "id": "backend.queues-messaging",
      "domain": "backend",
      "name": "queues messaging",
      "observable_behavior": "Handle message delivery, retries and poison messages.",
      "required_core": false
    },
    {
      "id": "backend.networking",
      "domain": "backend",
      "name": "networking",
      "observable_behavior": "Diagnose connection, naming and timeout failures at service boundaries.",
      "required_core": false
    },
    {
      "id": "distributed.consistency",
      "domain": "distributed",
      "name": "consistency",
      "observable_behavior": "State read/write guarantees and demonstrate an anomaly.",
      "required_core": false
    },
    {
      "id": "distributed.replication",
      "domain": "distributed",
      "name": "replication",
      "observable_behavior": "Explain replica lag and recovery under node loss.",
      "required_core": false
    },
    {
      "id": "distributed.partitioning",
      "domain": "distributed",
      "name": "partitioning",
      "observable_behavior": "Choose partition keys and diagnose skew.",
      "required_core": false
    },
    {
      "id": "distributed.transactions",
      "domain": "distributed",
      "name": "transactions",
      "observable_behavior": "Define atomicity boundaries and test partial failure.",
      "required_core": false
    },
    {
      "id": "distributed.consensus",
      "domain": "distributed",
      "name": "consensus",
      "observable_behavior": "Explain agreement and availability under failure assumptions.",
      "required_core": false
    },
    {
      "id": "distributed.idempotency",
      "domain": "distributed",
      "name": "idempotency",
      "observable_behavior": "Demonstrate safe duplicate requests or messages.",
      "required_core": false
    },
    {
      "id": "distributed.failure-recovery",
      "domain": "distributed",
      "name": "failure recovery",
      "observable_behavior": "Restore service after partial failure without hiding data loss.",
      "required_core": false
    },
    {
      "id": "distributed.backpressure",
      "domain": "distributed",
      "name": "backpressure",
      "observable_behavior": "Bound queues and explain overload propagation.",
      "required_core": false
    },
    {
      "id": "production.logging",
      "domain": "production",
      "name": "logging",
      "observable_behavior": "Record actionable context while excluding secrets.",
      "required_core": false,
      "prerequisites": [
        "core.implementation"
      ]
    },
    {
      "id": "production.metrics",
      "domain": "production",
      "name": "metrics",
      "observable_behavior": "Choose measurements tied to behavior and explain aggregation limits.",
      "required_core": false,
      "prerequisites": [
        "core.implementation"
      ]
    },
    {
      "id": "production.tracing",
      "domain": "production",
      "name": "tracing",
      "observable_behavior": "Connect spans to explain a request across boundaries.",
      "required_core": false
    },
    {
      "id": "production.observability",
      "domain": "production",
      "name": "observability",
      "observable_behavior": "Combine signals to distinguish competing failure hypotheses.",
      "required_core": false,
      "prerequisites": [
        "core.debugging",
        "production.metrics",
        "production.logging"
      ]
    },
    {
      "id": "production.reliability",
      "domain": "production",
      "name": "reliability",
      "observable_behavior": "Define reliability targets and test a degradation scenario.",
      "required_core": false
    },
    {
      "id": "production.incident-response",
      "domain": "production",
      "name": "incident response",
      "observable_behavior": "Triage impact, mitigate and document incident learning.",
      "required_core": false
    },
    {
      "id": "production.performance",
      "domain": "production",
      "name": "performance",
      "observable_behavior": "Measure a bottleneck with reproducible workloads and uncertainty.",
      "required_core": false
    },
    {
      "id": "production.deployment",
      "domain": "production",
      "name": "deployment",
      "observable_behavior": "Plan release verification and rollback.",
      "required_core": false
    },
    {
      "id": "production.ci-cd",
      "domain": "production",
      "name": "ci cd",
      "observable_behavior": "Build checks that detect bad changes and preserve diagnostics.",
      "required_core": false
    },
    {
      "id": "platform.containers",
      "domain": "platform",
      "name": "containers",
      "observable_behavior": "Explain isolation and resource limits of a containerized process.",
      "required_core": false
    },
    {
      "id": "platform.docker",
      "domain": "platform",
      "name": "docker",
      "observable_behavior": "Build and inspect a reproducible image and diagnose startup failure.",
      "required_core": false
    },
    {
      "id": "platform.kubernetes",
      "domain": "platform",
      "name": "kubernetes",
      "observable_behavior": "Explain workload reconciliation and diagnose scheduling or rollout failure.",
      "required_core": false
    },
    {
      "id": "platform.infrastructure-as-code",
      "domain": "platform",
      "name": "infrastructure as code",
      "observable_behavior": "Review infrastructure plans and detect drift without unauthorized mutation.",
      "required_core": false
    },
    {
      "id": "platform.aws",
      "domain": "platform",
      "name": "aws",
      "observable_behavior": "Explain AWS service boundaries, access and cost for a scoped design.",
      "required_core": false
    },
    {
      "id": "platform.azure",
      "domain": "platform",
      "name": "azure",
      "observable_behavior": "Explain Azure service boundaries, access and cost for a scoped design.",
      "required_core": false
    },
    {
      "id": "platform.autoscaling",
      "domain": "platform",
      "name": "autoscaling",
      "observable_behavior": "Choose a scaling signal and test lag or oscillation.",
      "required_core": false
    },
    {
      "id": "platform.networking",
      "domain": "platform",
      "name": "networking",
      "observable_behavior": "Trace connectivity across platform routing and policy boundaries.",
      "required_core": false
    },
    {
      "id": "python.language",
      "domain": "python",
      "name": "language",
      "observable_behavior": "Explain Python object and execution semantics in a change.",
      "required_core": false
    },
    {
      "id": "python.packaging",
      "domain": "python",
      "name": "packaging",
      "observable_behavior": "Build a reproducible package with explicit dependencies.",
      "required_core": false
    },
    {
      "id": "python.typing",
      "domain": "python",
      "name": "typing",
      "observable_behavior": "Use types to expose contract mistakes and explain runtime limits.",
      "required_core": false
    },
    {
      "id": "python.async",
      "domain": "python",
      "name": "async",
      "observable_behavior": "Reason about cancellation and blocking in asynchronous execution.",
      "required_core": false
    },
    {
      "id": "python.testing",
      "domain": "python",
      "name": "testing",
      "observable_behavior": "Design Python tests with controlled fixtures and meaningful failure cases.",
      "required_core": false,
      "prerequisites": [
        "python.language",
        "core.testing"
      ]
    },
    {
      "id": "python.performance",
      "domain": "python",
      "name": "performance",
      "observable_behavior": "Profile Python work before changing algorithms or execution strategy.",
      "required_core": false
    },
    {
      "id": "java.language",
      "domain": "java",
      "name": "language",
      "observable_behavior": "Explain Java types and control flow in a scoped change.",
      "required_core": false
    },
    {
      "id": "java.jvm",
      "domain": "java",
      "name": "jvm",
      "observable_behavior": "Relate runtime behavior to JVM memory, compilation or garbage collection.",
      "required_core": false
    },
    {
      "id": "java.concurrency",
      "domain": "java",
      "name": "concurrency",
      "observable_behavior": "Diagnose shared-state and executor behavior.",
      "required_core": false
    },
    {
      "id": "java.spring",
      "domain": "java",
      "name": "spring",
      "observable_behavior": "Explain Spring dependency wiring and lifecycle.",
      "required_core": false
    },
    {
      "id": "java.spring-boot",
      "domain": "java",
      "name": "spring boot",
      "observable_behavior": "Trace Spring Boot configuration and startup behavior.",
      "required_core": false
    },
    {
      "id": "java.persistence",
      "domain": "java",
      "name": "persistence",
      "observable_behavior": "Explain ORM queries and transaction boundaries.",
      "required_core": false
    },
    {
      "id": "cpp.memory",
      "domain": "cpp",
      "name": "memory",
      "observable_behavior": "Trace allocation, lifetime and invalid access.",
      "required_core": false
    },
    {
      "id": "cpp.raii",
      "domain": "cpp",
      "name": "raii",
      "observable_behavior": "Use ownership and destructors to manage resources on failure paths.",
      "required_core": false
    },
    {
      "id": "cpp.templates",
      "domain": "cpp",
      "name": "templates",
      "observable_behavior": "Explain template constraints and instantiation errors.",
      "required_core": false
    },
    {
      "id": "cpp.concurrency",
      "domain": "cpp",
      "name": "concurrency",
      "observable_behavior": "Reason about synchronization and memory ordering.",
      "required_core": false
    },
    {
      "id": "cpp.build-tooling",
      "domain": "cpp",
      "name": "build tooling",
      "observable_behavior": "Diagnose compilation, linking and dependency configuration.",
      "required_core": false
    },
    {
      "id": "cpp.performance",
      "domain": "cpp",
      "name": "performance",
      "observable_behavior": "Profile C++ workloads and verify optimization correctness.",
      "required_core": false
    },
    {
      "id": "go.idioms",
      "domain": "go",
      "name": "idioms",
      "observable_behavior": "Explain Go interfaces, errors and composition choices.",
      "required_core": false
    },
    {
      "id": "go.concurrency",
      "domain": "go",
      "name": "concurrency",
      "observable_behavior": "Bound goroutine lifetime and diagnose channel or synchronization failures.",
      "required_core": false
    },
    {
      "id": "go.networking",
      "domain": "go",
      "name": "networking",
      "observable_behavior": "Handle connection lifetime, deadlines and cancellation.",
      "required_core": false
    },
    {
      "id": "go.services",
      "domain": "go",
      "name": "services",
      "observable_behavior": "Build service boundaries with explicit failure handling.",
      "required_core": false
    },
    {
      "id": "go.controllers-operators",
      "domain": "go",
      "name": "controllers operators",
      "observable_behavior": "Explain reconciliation and repeated execution under partial failure.",
      "required_core": false
    },
    {
      "id": "ml.data-pipelines",
      "domain": "ml",
      "name": "data pipelines",
      "observable_behavior": "Inspect data distribution, leakage and lineage before transformation.",
      "required_core": false
    },
    {
      "id": "ml.experimentation",
      "domain": "ml",
      "name": "experimentation",
      "observable_behavior": "Compare a hypothesis against a credible baseline with controlled variables.",
      "required_core": false
    },
    {
      "id": "ml.evaluation",
      "domain": "ml",
      "name": "evaluation",
      "observable_behavior": "Choose metrics tied to decisions and probe misleading aggregate results.",
      "required_core": false
    },
    {
      "id": "ml.training",
      "domain": "ml",
      "name": "training",
      "observable_behavior": "Justify objective and optimization choices using observed training behavior.",
      "required_core": false
    },
    {
      "id": "ml.experiment-tracking",
      "domain": "ml",
      "name": "experiment tracking",
      "observable_behavior": "Record configurations and artifacts needed to reproduce an experiment.",
      "required_core": false
    },
    {
      "id": "ml.model-lifecycle",
      "domain": "ml",
      "name": "model lifecycle",
      "observable_behavior": "Manage model versions and detect degradation across release stages.",
      "required_core": false,
      "prerequisites": [
        "ml.evaluation"
      ]
    },
    {
      "id": "ml.serving",
      "domain": "ml",
      "name": "serving",
      "observable_behavior": "Measure prediction behavior under realistic serving constraints.",
      "required_core": false
    },
    {
      "id": "llm.transformer-inference",
      "domain": "llm",
      "name": "transformer inference",
      "observable_behavior": "Explain transformer inference compute and memory costs.",
      "required_core": false
    },
    {
      "id": "llm.batching",
      "domain": "llm",
      "name": "batching",
      "observable_behavior": "Measure batch policy effects on latency and utilization.",
      "required_core": false
    },
    {
      "id": "llm.kv-caching",
      "domain": "llm",
      "name": "kv caching",
      "observable_behavior": "Explain cache growth, reuse and eviction correctness.",
      "required_core": false
    },
    {
      "id": "llm.scheduling",
      "domain": "llm",
      "name": "scheduling",
      "observable_behavior": "Compare request scheduling under mixed workloads.",
      "required_core": false
    },
    {
      "id": "llm.model-loading",
      "domain": "llm",
      "name": "model loading",
      "observable_behavior": "Diagnose model weight loading and memory constraints.",
      "required_core": false
    },
    {
      "id": "llm.latency-throughput",
      "domain": "llm",
      "name": "latency throughput",
      "observable_behavior": "Measure latency distributions and throughput under stated load.",
      "required_core": false
    },
    {
      "id": "llm.distributed-inference",
      "domain": "llm",
      "name": "distributed inference",
      "observable_behavior": "Explain communication and partitioning costs across inference workers.",
      "required_core": false
    },
    {
      "id": "gpu.architecture",
      "domain": "gpu",
      "name": "architecture",
      "observable_behavior": "Relate execution behavior to GPU compute organization.",
      "required_core": false
    },
    {
      "id": "gpu.memory-hierarchy",
      "domain": "gpu",
      "name": "memory hierarchy",
      "observable_behavior": "Measure memory access effects across the GPU hierarchy.",
      "required_core": false
    },
    {
      "id": "gpu.cuda",
      "domain": "gpu",
      "name": "cuda",
      "observable_behavior": "Explain CUDA execution, synchronization and error behavior.",
      "required_core": false
    },
    {
      "id": "gpu.kernel-design",
      "domain": "gpu",
      "name": "kernel design",
      "observable_behavior": "Design a kernel with explicit indexing and correctness checks.",
      "required_core": false
    },
    {
      "id": "gpu.profiling",
      "domain": "gpu",
      "name": "profiling",
      "observable_behavior": "Use profiler evidence to isolate GPU bottlenecks.",
      "required_core": false
    },
    {
      "id": "gpu.optimization",
      "domain": "gpu",
      "name": "optimization",
      "observable_behavior": "Validate speed changes against numerical correctness and workload coverage.",
      "required_core": false
    },
    {
      "id": "data.sql",
      "domain": "data",
      "name": "SQL",
      "observable_behavior": "Write and validate queries whose joins, aggregation and null handling match the analytical question.",
      "required_core": false,
      "prerequisites": [
        "core.implementation"
      ]
    },
    {
      "id": "data.analytics",
      "domain": "data",
      "name": "analytics",
      "observable_behavior": "Translate a decision question into defensible measures, slices and limitations.",
      "required_core": false
    },
    {
      "id": "data.visualization",
      "domain": "data",
      "name": "visualization",
      "observable_behavior": "Choose visual encodings that communicate the result without hiding uncertainty or scale.",
      "required_core": false
    },
    {
      "id": "data.quality",
      "domain": "data",
      "name": "data quality",
      "observable_behavior": "Detect and explain missing, inconsistent, duplicated or drifting data before relying on it.",
      "required_core": false,
      "prerequisites": [
        "data.sql",
        "core.testing"
      ]
    },
    {
      "id": "research.reproducibility",
      "domain": "research",
      "name": "reproducibility",
      "observable_behavior": "Make an experiment repeatable from pinned inputs, code, configuration and reported conditions.",
      "required_core": false
    },
    {
      "id": "research.experimental-design",
      "domain": "research",
      "name": "experimental design",
      "observable_behavior": "Design a comparison that controls plausible confounders and can falsify the stated hypothesis.",
      "required_core": false
    },
    {
      "id": "research.paper-implementation",
      "domain": "research",
      "name": "paper implementation",
      "observable_behavior": "Translate a published method into code while identifying underspecified assumptions and deviations.",
      "required_core": false
    },
    {
      "id": "math.probability-statistics",
      "domain": "math",
      "name": "probability and statistics",
      "observable_behavior": "Choose and justify probabilistic assumptions and quantify uncertainty in a result.",
      "required_core": false
    },
    {
      "id": "math.numerical-methods",
      "domain": "math",
      "name": "numerical methods",
      "observable_behavior": "Analyze approximation error, stability and convergence for a numerical computation.",
      "required_core": false
    },
    {
      "id": "math.optimization",
      "domain": "math",
      "name": "optimization",
      "observable_behavior": "Formulate an objective and constraints and diagnose when the chosen optimization method fails.",
      "required_core": false
    },
    {
      "id": "math.formal-reasoning",
      "domain": "math",
      "name": "formal reasoning",
      "observable_behavior": "State assumptions and construct or check a logically valid argument or proof.",
      "required_core": false
    },
    {
      "id": "ai.retrieval-augmentation",
      "domain": "ai",
      "name": "retrieval augmentation",
      "observable_behavior": "Design and evaluate retrieval, grounding and citation behavior against realistic queries.",
      "required_core": false,
      "prerequisites": [
        "ml.evaluation"
      ]
    },
    {
      "id": "ai.agent-design",
      "domain": "ai",
      "name": "agent design",
      "observable_behavior": "Bound an agent loop with explicit tools, state, termination and failure behavior.",
      "required_core": false,
      "prerequisites": [
        "core.implementation"
      ]
    },
    {
      "id": "ai.safety-evaluation",
      "domain": "ai",
      "name": "AI safety evaluation",
      "observable_behavior": "Test an AI system for concrete misuse, unsafe output and control failures relevant to its deployment.",
      "required_core": false,
      "prerequisites": [
        "ml.evaluation"
      ]
    },
    {
      "id": "product.requirements-discovery",
      "domain": "product",
      "name": "requirements discovery",
      "observable_behavior": "Turn stakeholder workflows and constraints into testable requirements while preserving unresolved questions.",
      "required_core": false
    },
    {
      "id": "product.integration-delivery",
      "domain": "product",
      "name": "integration delivery",
      "observable_behavior": "Integrate a solution into an existing environment with explicit ownership, compatibility and rollout boundaries.",
      "required_core": false
    },
    {
      "id": "product.outcome-validation",
      "domain": "product",
      "name": "outcome validation",
      "observable_behavior": "Measure whether delivered behavior improves the decision or workflow it was intended to support.",
      "required_core": false
    },
    {
      "id": "quant.market-data",
      "domain": "quant",
      "name": "market data",
      "observable_behavior": "Model market data timing, adjustments and quality without introducing look-ahead bias.",
      "required_core": false
    },
    {
      "id": "quant.backtesting",
      "domain": "quant",
      "name": "backtesting",
      "observable_behavior": "Build a backtest that accounts for leakage, execution assumptions, costs and unstable regimes.",
      "required_core": false
    },
    {
      "id": "quant.portfolio-modeling",
      "domain": "quant",
      "name": "portfolio modeling",
      "observable_behavior": "Explain portfolio construction and risk behavior under stated assumptions and constraints.",
      "required_core": false
    },
    {
      "id": "quant.execution-systems",
      "domain": "quant",
      "name": "execution systems",
      "observable_behavior": "Design order and execution handling with explicit latency, idempotency and failure semantics.",
      "required_core": false
    },
    {
      "id": "ml.feature-engineering",
      "domain": "ml",
      "name": "feature engineering",
      "observable_behavior": "Build reproducible features while preventing train-serving skew and target leakage.",
      "required_core": false
    },
    {
      "id": "ml.distributed-training",
      "domain": "ml",
      "name": "distributed training",
      "observable_behavior": "Explain and measure synchronization, partitioning and recovery behavior in a multi-worker training run.",
      "required_core": false
    },
    {
      "id": "frontend.web-platform",
      "domain": "frontend",
      "name": "web platform",
      "observable_behavior": "Implement browser behavior using documented platform semantics and verify compatibility boundaries.",
      "required_core": false,
      "prerequisites": [
        "core.implementation"
      ]
    },
    {
      "id": "frontend.accessibility",
      "domain": "frontend",
      "name": "accessibility",
      "observable_behavior": "Test keyboard, semantic, and assistive-technology behavior against an explicit accessibility requirement.",
      "required_core": false,
      "prerequisites": [
        "frontend.web-platform",
        "core.testing"
      ]
    },
    {
      "id": "frontend.state-management",
      "domain": "frontend",
      "name": "state management",
      "observable_behavior": "Model client state ownership and demonstrate correct transitions under asynchronous updates.",
      "required_core": false,
      "prerequisites": [
        "frontend.web-platform",
        "core.debugging"
      ]
    },
    {
      "id": "frontend.performance",
      "domain": "frontend",
      "name": "frontend performance",
      "observable_behavior": "Measure a user-facing performance bottleneck and validate a targeted improvement.",
      "required_core": false,
      "prerequisites": [
        "frontend.web-platform",
        "core.debugging"
      ]
    },
    {
      "id": "fullstack.end-to-end-delivery",
      "domain": "fullstack",
      "name": "end-to-end delivery",
      "observable_behavior": "Trace and deliver one behavior across interface, service, and persistence boundaries.",
      "required_core": false
    },
    {
      "id": "data.orchestration",
      "domain": "data",
      "name": "data orchestration",
      "observable_behavior": "Design and operate retryable data workflows with observable dependencies and failure recovery.",
      "required_core": false
    },
    {
      "id": "data.batch-streaming",
      "domain": "data",
      "name": "batch and streaming",
      "observable_behavior": "Choose batch or streaming semantics and test lateness, replay, and ordering assumptions.",
      "required_core": false,
      "prerequisites": [
        "data.quality"
      ]
    },
    {
      "id": "database.query-planning",
      "domain": "database",
      "name": "query planning",
      "observable_behavior": "Explain a query plan and validate an index or rewrite against measured behavior.",
      "required_core": false,
      "prerequisites": [
        "backend.databases",
        "data.sql"
      ]
    },
    {
      "id": "database.storage-engines",
      "domain": "database",
      "name": "storage engines",
      "observable_behavior": "Trace persistence, caching, and recovery behavior through a storage engine.",
      "required_core": false
    },
    {
      "id": "sre.slo-error-budgets",
      "domain": "sre",
      "name": "SLOs and error budgets",
      "observable_behavior": "Define a measurable service objective and use its error budget to justify an operational decision.",
      "required_core": false,
      "prerequisites": [
        "production.metrics"
      ]
    },
    {
      "id": "sre.capacity-planning",
      "domain": "sre",
      "name": "capacity planning",
      "observable_behavior": "Estimate capacity from workload evidence and test the first saturation assumption.",
      "required_core": false
    },
    {
      "id": "sre.incident-management",
      "domain": "sre",
      "name": "incident management",
      "observable_behavior": "Coordinate diagnosis, mitigation, and follow-up using a timestamped incident record.",
      "required_core": false,
      "prerequisites": [
        "production.observability",
        "core.technical-communication"
      ]
    },
    {
      "id": "observability.instrumentation",
      "domain": "observability",
      "name": "instrumentation",
      "observable_behavior": "Add telemetry that answers a stated operational question without misleading cardinality or sampling.",
      "required_core": false,
      "prerequisites": [
        "production.metrics",
        "production.logging"
      ]
    },
    {
      "id": "observability.telemetry-pipelines",
      "domain": "observability",
      "name": "telemetry pipelines",
      "observable_behavior": "Trace collection, processing, export, and loss behavior across a telemetry pipeline.",
      "required_core": false
    },
    {
      "id": "security.threat-modeling",
      "domain": "security",
      "name": "threat modeling",
      "observable_behavior": "Identify assets, trust boundaries, abuse paths, and testable mitigations for a concrete change.",
      "required_core": false
    },
    {
      "id": "security.secure-development",
      "domain": "security",
      "name": "secure development",
      "observable_behavior": "Implement and test secure defaults at an identified trust boundary.",
      "required_core": false
    },
    {
      "id": "security.vulnerability-management",
      "domain": "security",
      "name": "vulnerability management",
      "observable_behavior": "Triage a finding using reachability, impact, fix evidence, and residual risk.",
      "required_core": false
    },
    {
      "id": "appsec.static-dynamic-analysis",
      "domain": "appsec",
      "name": "static and dynamic analysis",
      "observable_behavior": "Configure and validate analysis findings while documenting false-positive and coverage limits.",
      "required_core": false
    },
    {
      "id": "appsec.web-security",
      "domain": "appsec",
      "name": "web security",
      "observable_behavior": "Reproduce and remediate a web vulnerability with regression evidence.",
      "required_core": false
    },
    {
      "id": "tooling.cli-design",
      "domain": "tooling",
      "name": "CLI design",
      "observable_behavior": "Design stable command behavior including diagnostics, exit status, and automation-safe output.",
      "required_core": false
    },
    {
      "id": "tooling.static-analysis",
      "domain": "tooling",
      "name": "static analysis",
      "observable_behavior": "Implement or tune a deterministic rule and validate precision on positive and negative cases.",
      "required_core": false
    },
    {
      "id": "tooling.build-systems",
      "domain": "tooling",
      "name": "build systems",
      "observable_behavior": "Trace dependency and cache behavior through a reproducible build.",
      "required_core": false
    },
    {
      "id": "compiler.parsing-lowering",
      "domain": "compiler",
      "name": "parsing and lowering",
      "observable_behavior": "Trace source syntax into an intermediate representation and test invalid input behavior.",
      "required_core": false
    },
    {
      "id": "compiler.optimization",
      "domain": "compiler",
      "name": "compiler optimization",
      "observable_behavior": "Implement or analyze a semantics-preserving optimization with counterexamples.",
      "required_core": false
    },
    {
      "id": "compiler.codegen",
      "domain": "compiler",
      "name": "code generation",
      "observable_behavior": "Trace an intermediate representation into target code and validate target-specific behavior.",
      "required_core": false
    },
    {
      "id": "quality.test-strategy",
      "domain": "quality",
      "name": "test strategy",
      "observable_behavior": "Select test layers from failure risk and state what each layer cannot prove.",
      "required_core": false
    },
    {
      "id": "quality.automation",
      "domain": "quality",
      "name": "quality automation",
      "observable_behavior": "Build a deterministic quality check with actionable failure output.",
      "required_core": false
    },
    {
      "id": "quality.reliability",
      "domain": "quality",
      "name": "reliability testing",
      "observable_behavior": "Design repeatable tests for concurrency, recovery, or environmental failure.",
      "required_core": false
    },
    {
      "id": "mobile.platform-integration",
      "domain": "mobile",
      "name": "platform integration",
      "observable_behavior": "Implement and test behavior across shared code and a native platform boundary.",
      "required_core": false
    },
    {
      "id": "mobile.performance",
      "domain": "mobile",
      "name": "mobile performance",
      "observable_behavior": "Measure and improve startup, rendering, memory, or network behavior on a target device profile.",
      "required_core": false
    },
    {
      "id": "mobile.release",
      "domain": "mobile",
      "name": "mobile release",
      "observable_behavior": "Produce a reproducible signed release candidate and document rollout and rollback constraints.",
      "required_core": false
    },
    {
      "id": "embedded.real-time",
      "domain": "embedded",
      "name": "real-time behavior",
      "observable_behavior": "Measure timing behavior and validate a deadline or scheduling assumption.",
      "required_core": false
    },
    {
      "id": "embedded.hardware-interfaces",
      "domain": "embedded",
      "name": "hardware interfaces",
      "observable_behavior": "Implement and test a device interface with explicit electrical or protocol assumptions.",
      "required_core": false
    },
    {
      "id": "embedded.resource-constraints",
      "domain": "embedded",
      "name": "resource constraints",
      "observable_behavior": "Measure memory, power, or compute use and validate operation within a fixed budget.",
      "required_core": false
    },
    {
      "id": "network.protocols",
      "domain": "network",
      "name": "network protocols",
      "observable_behavior": "Trace protocol state and reproduce timeout, retry, or malformed-message behavior.",
      "required_core": false
    },
    {
      "id": "network.routing-proxying",
      "domain": "network",
      "name": "routing and proxying",
      "observable_behavior": "Configure and diagnose routing across naming, proxy, and load-balancing boundaries.",
      "required_core": false
    },
    {
      "id": "network.tls",
      "domain": "network",
      "name": "TLS",
      "observable_behavior": "Explain and test certificate, identity, negotiation, and failure behavior for a secured connection.",
      "required_core": false
    },
    {
      "id": "game.engine-architecture",
      "domain": "game",
      "name": "game engine architecture",
      "observable_behavior": "Trace frame, scene, asset, and system ownership through an engine change.",
      "required_core": false
    },
    {
      "id": "game.rendering",
      "domain": "game",
      "name": "rendering",
      "observable_behavior": "Implement or diagnose a rendering path using measurable frame and visual evidence.",
      "required_core": false
    },
    {
      "id": "game.performance",
      "domain": "game",
      "name": "game performance",
      "observable_behavior": "Profile frame time or resource use and validate a targeted optimization.",
      "required_core": false
    }
  ],
  "last_awarded_level": "E0",
  "standing": "current",
  "stale_record_ids": []
}
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 196kUpdated Claude CodeCodexVerifiedInstall