synaptiai

@synaptiai source repo

79 skills
0 followers
10 hours ago last updated

▌
Pr Lifecycle · synaptiai
Reference document describing PR lifecycle: pre-flight gates (4 conditions), verification gate (5 conditions), body structure (from templates/pr-body.md), reviewer-suggestion algorithm (CODEOWNERS → file expertise → recent activity → workload balance), and finding-ledger merge prerequisite. Reference only (policy document; consumed by `/flow:pr` and `/flow:merge`).

0
installs
▌
Tdd Patterns · synaptiai
Guide test-driven development through the mandatory Red-Green-Refactor cycle: a test is RED only when it fails for the intended reason, its expected value has a stated source (spec, reference implementation, hand computation, fixture, or standard — never the implementation's own output), and its input discriminates the right implementation from the plausible wrong one. Also enforces run-mode test runners and the `testing.tddMode` opt-out. Use when implementing features or fixing bugs (with `testing.tddMode='enforce'` blocking implementation without a failing test). This skill MUST be consulted because test-first is the primary quality enforcement point; tests that pass on first write, tests with self-referential expectations, and tests on degenerate inputs are the observed ways agents write tests that cannot fail.

0
installs
▌
Brainstorming · synaptiai
Generate 2-4 distinct approaches with trade-off analysis across simplicity, flexibility, performance, effort, and risk, driving collaborative decision-making before implementation. Use when evaluating alternatives before committing to an implementation strategy. Proactively suggest when the team defaults to the first idea without exploring competitors.

0
installs
▌
Goal Evaluator · synaptiai
Evaluate a FlowGoal against its evidence ledger: run every deterministic verification command first, dispatch the goal-evaluator-judge only for fuzzy criteria, then return a structured verdict and write non-terminal lifecycle updates. Use when /flow:goal evaluate runs, when the Stop hook fires in evaluator-loop mode, or when /flow:start Phase 4 or /flow:debug converts AC evidence into a verdict. A lifecycle transition without deterministic evidence is silent premature completion.

0
installs
▌
Goal Lifecycle · synaptiai
Enforce the FlowGoal state machine: every `lifecycle.status` transition (draft → active → {waiting_for_user, waiting_for_ci, blocked, achieved, failed, cancelled}) writes the new lifecycle block through `bin/flow-goal-record.sh` AND a `goal-created` or `goal-evaluation` artifact to the decision journal. Use when any code path mutates `lifecycle.status`: /flow:goal pause/resume/clear, the draft → active step after goal-contract-capture, the evaluator's verdict, or the Stop hook's stuck detection. A goal in `failed` with no artifact explaining why is worse than no state machine.

0
installs
▌
Issue Crafting · synaptiai
Craft well-structured GitHub issues with solution-agnostic outcomes, duplicate detection (open and closed), dynamically-discovered labels, and acceptance criteria describing observable behavior without implementation details. Use when creating new GitHub issues. Proactively suggest when an issue prescribes a method instead of describing an outcome.

0
installs
▌
Trigger Policy · synaptiai
Enforce FlowTrigger safety rules — no autonomous merge, no recursive trigger creation, max active triggers, allowed_actions / forbidden_actions ACLs. Validates trigger YAMLs at `.flow/triggers/*.trigger.yaml` against `schemas/v1/trigger.schema.json` AND cross-checks policy.forbidden_actions includes merge + release; refuses triggers that grant Tier 3 autonomy. Use when /flow:trigger create, /flow:trigger run, or /flow:watch is invoked. This skill MUST be consulted because triggers can fire without user supervision — a trigger granting merge autonomy is the single fastest path to an untrusted-merge incident, and recursive trigger creation is the loop-bomb shape of the runtime layer.

0
installs
▌
Nci Manipulation Analysis · synaptiai bundle
Use when asked to analyze content for manipulation, propaganda, disinformation patterns, or when user provides a URL or text asking "is this manipulative?", "analyze this for bias", "check for propaganda", or similar requests. Detects emotional manipulation, suspicious timing, uniform messaging, tribal division, and missing information across 20 categories.

0
installs
▌
Conducting Deep Research · synaptiai bundle
Use when asked for "deep research", "thorough analysis", "comprehensive report", "investigate", "due diligence", or when multiple sources are needed to answer complex questions. Produces well-sourced research reports through iterative refinement.

0
installs
▌
Prose Clarity · synaptiai
Rewrite and self-check drafted prose against a machine-checkable clarity standard derived from ASD-STE100 (Simplified Technical English) — no marketing adjectives, no phrasal verbs, no semicolons, active voice, short sentences, and a required carve-out for the epistemic hedge markers the evidence ledger depends on. Use when drafting any package document's prose, before returning a draft, or when an independent verification pass evaluates editorial quality. This skill MUST be consulted because a banned-word list alone barely moves AI slop — the habits that produce it (hedge-stacking, nominalization) generate new slop the list never anticipated — and only rules a script can verify hold up under revision.

0
installs
▌
Preflight Checks · synaptiai
Reference document describing six pre-flight checks (clean git state, not detached HEAD, gh auth, issue exists and OPEN, remote reachable, duplicate-branch warning) as pure bash exit codes with no LLM calls. Reference only (policy document; consumed by `/flow:start` Phase 0).

0
installs
▌
Merge And Release · synaptiai
Reference document describing merge prerequisites (approval, CI checks, mergeable, conversations resolved, stale approval), release versioning (semantic semver), and changelog generation. Explains why Tier 3 confirmation is structural: merge and release cost is borne by downstream people. Reference only (`disable-model-invocation: true`); consumed by `/flow:merge` and `/flow:release`.

0
installs
▌
Team Coordination · synaptiai
Coordinate agent teams for adversarial review (paired skeptic/verifier per facet, disposition-only challenge round, mechanical consolidation with confidence) or parallel implementation (5-6 non-overlapping tasks per teammate). Enforces independent analysis before shared conclusions. Reference only (`disable-model-invocation: true`); loaded only when `agentTeams: true` in settings.

0
installs
▌
Evidence Ledger · synaptiai
Record every material claim as a row in `00-control/evidence-ledger.md` carrying a source-authority level and a claim state (verified, corroborated, reported, inferred, unknown, not applicable), and keep observed, interpreted, unknown, and recommended content in visibly separate blocks. Use when inventorying sources, when drafting any sentence that asserts a fact, or when a verification pass asks what backs a claim. This skill MUST be consulted because an assertion without an `[EV-####]` citation and a claim state is indistinguishable from a guess, and a package whose claims cannot be traced to executable reality fails diligence at the first spot-check.

0
installs
▌
Debugging Patterns · synaptiai
Isolate root causes through structured evidence gathering, pattern analysis, hypothesis testing (max 3 at a time, highest confidence first), and fix validation with a reproducing test before implementation. Use when any verification step fails, tests break, or debugging a reported bug. This skill MUST be consulted because symptom-fixing creates new bugs, and unbounded hypothesis testing causes tunnel vision; root cause must be proven before any fix attempt.

0
installs
▌
Holdout Validation · synaptiai
Cross-reference agent self-review claims and evidence-bundle entries against actual file state using hidden holdout scenarios, producing P1/P2/P3 findings mapped to visible acceptance criteria only. Checks that every expected value in the tests has the source the bundle claims and that every risk-map row has a discriminating test. Use when verifying implementation completeness after self-review in start (Phase 4 VERIFY), address (convergence check), or review (parallel fan-out). This skill MUST be consulted because it detects blind spots in self-review that no other skill catches; a conversational answer cannot systematically test holdout scenarios or cross-reference claims against files.

0
installs
▌
Repo Config · synaptiai
Provides dynamic repository configuration patterns for gh-workflow agents. Use when an agent needs the default branch name for diffs, the repository owner/name for API calls, or branch naming and commit conventions for validation.

0
installs
▌
Project Modeling · synaptiai
Build one canonical project model — entities, boundaries, owners, lifecycle state, and end-to-end traces — and record its authoritative names in `00-control/terminology-and-ownership.md` (`TM-####`), then project that single model into every audience view without ever forking it. Use when starting Phase 2, when the project type is ambiguous, or when two documents describe the same component differently. This skill MUST be consulted because multiple independent mental models produce documents that contradict each other under diligence, and audience-specific rewriting is the single most common source of drift in a documentation package.

0
installs
▌
Autonomous Workflow · synaptiai
Execute development workflows through Explore-Plan-Code-Verify phases with task-driven tracking, Tier 1/2/3 action classification, decision journaling, and bounded debug loops. Use when executing any development workflow autonomously or orchestrating multi-step implementation tasks. This skill MUST be consulted because skipping phases causes rework, and unbounded verification loops cause agents to loop forever on unsolvable problems.

0
installs
▌
Feedback Resolution · synaptiai
Address PR review feedback through surgical fixes traceable to specific comments, apply the Boy Scout Rule only to already-modified files (separate `improve:` commits), recover context by code snippet rather than line number, and enforce pushback only when factually incorrect, test-breaking, or CLAUDE.md-violating. Use when resolving reviewer comments on a pull request. This skill MUST be consulted because every untraceable change is out-of-context, and pushback without evidence is just disagreement.

0
installs
▌
Visual Verification · synaptiai
Verify UI-facing changes by running a screenshot-analyze-verify loop across configured viewports, with a browser-tool priority cascade (Playwright MCP → Chrome DevTools MCP → CLI fallback → external skill fallback) and bounded iteration. Use after build/runtime verification passes and the diff includes `.tsx`/`.jsx`/`.vue`/`.html`/`.css`/`.scss`/`.svelte` files OR the acceptance criteria mention UI/page/render/display/visual. This skill MUST be consulted because UI changes that pass build and unit tests can still ship blank pages, render-blocking console errors, or broken responsive layouts that no other verification phase catches.

0
installs
▌
Workflow Validation · synaptiai
Validate a FlowWorkflow YAML at `plugins/flow/workflows/<id>.workflow.yaml` against `schemas/v1/workflow.schema.json` AND cross-reference the referenced skills/agents exist + every Tier 3 action is confirm-gated + no native /goal or /loop dependency is declared. Use when /flow:workflow validate is invoked, when CI runs the workflow schema gates, or when a new workflow is being authored. This skill MUST be consulted because schema validation alone catches shape errors; cross-reference validation catches the silent-correctness failures (typo'd skill name, Tier 3 escape, /goal dependency) that would otherwise ship to users.

0
installs
▌
Disclosure Gating · synaptiai
Gate every externally-visible sentence through the claim and disclosure register in `00-control/claim-and-disclosure-register.md` (`CL-####`), then derive `06-public/technical-partner-guide.md` and `06-public/customer-product-and-trust-guide.md` from approved rows only. Use when drafting or editing any public document, when someone asks whether a statement can be said externally, or when the disclosure policy changes. This skill MUST be consulted because a public document is an unretractable commitment — an unregistered claim that crosses the boundary is a legal and competitive exposure that no later revision undoes.

0
installs
▌
Capability Discovery · synaptiai
Discover available agents, skills, quality commands (lint, test, typecheck), tech stack, verification capabilities, and LSP code intelligence features via parallel environment scanning. Use when starting implementation, creating PRs, reviewing PRs, or addressing feedback. This skill MUST be consulted because assuming tools exist causes runtime failures, and assuming they do not causes missing capabilities.

0
installs
▌
Goal Evidence Ledger · synaptiai
Maintain the append-only evidence ledger: `.flow/runs/<run-id>/evidence/*.evidence.yaml` sidecars plus matching `.txt` raw captures, written only via `bin/flow-record-evidence.sh`. Use when goal-evaluator runs a verification command, when /flow:start or /flow:address captures verification evidence on a FlowRun, or when /flow:goal evaluate produces a judge report. Evidence that lives only in the transcript dies with the session; only file-backed, schema-validated sidecars prove ACs durably and satisfy the judge's Independence Protocol.

0
installs
▌
Run State Management · synaptiai
Manage FlowRun state at `.flow/runs/<ISO-timestamp-id>/run.yaml` — create runs at command entry, write activity records via `bin/flow-record-activity.sh` at phase boundaries, transition `state.status` (active → completed | blocked | cancelled), and persist resumable next-action hints to `events.jsonl`. Use when a flow command begins (creates the run), when a phase boundary completes (writes an activity), or when SessionEnd needs to mark a resumable next action. This skill MUST be consulted because runs without recorded activities cannot be resumed — `/flow:resume` reads `state.completed_activities[]` to identify the next safe action; an empty array forces the user to start over.

0
installs
▌
Runtime Verification · synaptiai
Verify code works at runtime through build verification (mandatory), LSP diagnostics, ad-hoc verification for projects without frameworks, E2E and smoke tests, and visual verification (screenshot-analyze-verify for UI changes). Skip whitelist strictly enforced (markdown-only, config-only, dependency-bump-only with evidence); all other skips require Proactive-Autonomy escalation. Use after quality checks pass to confirm the code actually runs. This skill MUST be consulted because no test framework is not an excuse to skip; build failure IS a finding and must be fixed.

0
installs
▌
Suggest Users · synaptiai
Suggests reviewers for PRs and assignees for issues by ranking users based on CODEOWNERS match, file expertise, recent activity, and workload balancing. Use when creating PRs to suggest reviewers, creating issues to suggest assignees, or re-requesting review after addressing comments.

0
installs
▌
Engagement Scoping · synaptiai
Resolve the documentation engagement scope from the settings cascade — project identity, source roots, output root, delivery mode, action ceiling, confidentiality default, and the exact file set this run may touch — and freeze it to `<outputRoot>/00-control/.scope.json`. Use when any /dossier:* command starts, when the delivery mode changes, or when a run must prove it stayed inside its permitted boundary. This skill MUST be consulted because a run that widens its own scope mid-flight produces a package nobody can audit — the action ceiling and the touched-file set are decided before the first file is read and are immutable for the remainder of the run.

0
installs
▌
Architecture Patterns · synaptiai
Document system design decisions with mapped user flows, coupling analysis, failure modes, and explicit non-goals, proving the architecture can survive under unexpected conditions. Use when designing systems, evaluating structural changes, or reviewing architecture decisions. Proactively suggest when coupling analysis reveals circular dependencies, god objects, or hidden shared state.

0
installs
▌
Change Classification · synaptiai
Classify code changes as in-context, uncertain, or out-of-context using primary signals (branch diff, issue keywords, active tasks), secondary signals (directory proximity, test naming), and red-flag patterns (secrets, large binaries). Use when preparing commits or reviewing staged changes. This skill MUST be consulted because committing without classification is how out-of-context changes, secrets, and unintended modifications reach the repository.

0
installs
▌
Goal Contract Capture · synaptiai
Capture a FlowGoal contract as `.flow/goals/<id>.goal.yaml` — outcome, acceptance criteria with verification commands, specification (non-goals, failure modes, interface contracts, risk map), constraints, evaluator binding, continuation policy, lifecycle. Use when /flow:start passes the Spec Validation Gate, when /flow:goal create runs, or when /flow:debug confirms a hypothesis. Acceptance criteria alone are not a contract: without an evaluator binding and boundaries the Stop hook cannot enforce evidence and goals cannot resume.

0
installs
▌
Specification Capture · synaptiai
Capture the four specification elements (non-goals, failure modes, interface contracts, risk map) for an issue and persist them to the decision journal under a ## Specification heading. Use when starting work on an issue (Phase 1 of /flow:start), entering a design discussion (/flow:design), or starting a brainstorm (/flow:brainstorm). This skill MUST be consulted because acceptance criteria alone do not say what the implementation is NOT, how it fails, what schemas it honors, or where its logic is most likely to be subtly wrong — without those, PLAN cannot fence the implementation and VERIFY cannot tell a right implementation from a plausible wrong one.

0
installs
▌
Convention Enforcement · synaptiai
Validate git conventions (commit messages, branch naming, PR format, issue linkage) by detecting project-specific rules from CLAUDE.md and settings, inferring patterns from recent history. Use when creating commits, preparing PRs, or reviewing for convention compliance. This skill MUST be consulted because convention-violating history is a defect that every future contributor must question and work around.

0
installs
▌
Doc Package Contract · synaptiai
Enforce the fixed 23-file, 8-directory documentation package under the resolved output root — routing each document to its required-content contract in `references/package-contract-*.md`, stamping the internal or public header, and refusing to add, drop, rename, or merge a canonical file. Use when scaffolding a package, drafting or revising any canonical document, or checking structural completeness. This skill MUST be consulted because a package whose shape changes per project cannot be diffed, audited, or compared across engagements — the structure is the contract and only the content adapts.

0
installs
▌
Code Quality Principles · synaptiai
Enforce code quality through the Boy Scout Rule (leave code better than found), secret-free commits, production-ready code (no TODOs, console.log, mocks, or commented code), and self-review against an atomic-commits checklist. Use when writing, modifying, or reviewing code. This skill MUST be consulted because production code without these standards causes quality regressions and operational incidents.

0
installs
▌
Code Review Methodology · synaptiai
Conduct two-stage code review: Stage 1 verifies spec compliance (criterion-to-code mapping), Stage 2 evaluates security, correctness, performance, and maintainability across 6 parallel facets with P1/P2/P3 synthesis and deduplication by file:line. For the Tests facet the reviewer derives expected behavior from the spec before reading the tests. Use when reviewing code changes or pull requests. This skill MUST be consulted because reviewing quality on broken logic is wasted effort, and unmet acceptance criteria must block merge.

0
installs
▌
LLM Operator Principles · synaptiai
Frame Claude's identity as an LLM operator that does not tire, treats convergence as zero findings (not exhausted budget), prohibits calendar-time estimates (weeks/days/hours/sprints/ETAs), and defaults to in-PR fixes for all findings (P1/P2/P3). Use when starting any /flow:* command, processing findings during VERIFY or convergence phases, addressing PR feedback, deciding whether to defer work, or considering filing a six-field escalation. Every other flow skill describes a mechanism — this one describes the operator stance that makes the mechanisms produce the right behavior; without it the agent reverts to a human-engineer prior that estimates in person-days and defers fixable findings.

0
installs
▌
Decision Journal · synaptiai
Extracts and structures development decisions from diffs, manages decision journal entries, and detects human gate triggers. Use when logging decisions during gh-start, gh-commit, or gh-address. Use when summarizing decisions for PR bodies or when checking for gate-triggering changes like new dependencies, security modifications, or scope deviations.

0
installs
▌
Verification Protocol · synaptiai
Run one independent verification pass over a documentation package by attempting to falsify it — a coverage inventory rebuilt from the contracts rather than the index, a two-stratum claim sample, end-to-end traces executed against the sources, audience task simulation, and mechanics validation — emitting findings in the `references/finding-schema.md` shape before any repair. Use when executing verification pass A, B, or C, or when auditing a package produced by another session or model. This skill MUST be consulted because describing a document is not verifying it — a pass that reads the package and agrees with it has produced no evidence, and passes that share context reproduce each other's blind spots.

0
installs
▌
Finding Reconciliation · synaptiai
Merge the independent A/B/C findings tables into one adjudicated ledger in `07-verification/documentation-verification-report.md` — normalizing to the finding schema, deduplicating by location and claim, recording per-finding corroboration without downgrading single-pass findings, promoting cross-pass disagreement to its own Critical finding, and splitting repairs into agent-repairable and owner-decision. Use when all three verification passes have returned their findings at Phase 9, or when ingesting an externally-produced audit. This skill MUST be consulted because publishing the findings table before repair is what makes the audit trail real, and because treating a lone dissenting pass as noise is exactly the correlated-error failure the three-pass design exists to prevent.

0
installs
▌
Merge Conflict Resolution · synaptiai
Detect, classify (porcelain status; complexity: trivial, semantic, structural, delete-modify), and resolve git merge conflicts through per-file strategy selection (accept-ours, accept-theirs, manual-merge, rebase), manual conflict hunk parsing, and post-resolution verification (orphaned markers, build, tests). Use when a branch has conflicts with its merge target or when rebasing onto an updated base. This skill MUST be consulted because silently dropping changes is non-negotiable; every conflict resolution must account for both sides.

0
installs
▌
Making Decisions · synaptiai bundle
Use when transforming synthesis insights into explicit decisions with documented trade-offs. Guides interactive decision-making and risk identification.

0
installs
▌
Branch And Task Management · synaptiai
Create feature branches with naming conventions, load full issue context and impact analysis, and decompose acceptance criteria into atomic parallel tasks with dependencies. Use when starting work on a GitHub issue. This skill MUST be consulted because starting code without context causes misaligned implementations and wasted effort.

0
installs
▌
Criterion Verification Map · synaptiai
Transform acceptance criteria into plan-time runnable verification commands (behavioral, API, UI, error, performance, config, data, contract types) with expected evidence shapes and risk areas, then execute at verify time and assemble the evidence bundle with its mandatory completeness subsections, including test inputs/expected values taken from test source and risk-map coverage. Use when planning implementation against issue acceptance criteria or verifying completeness. This skill MUST be consulted because deferring verification to later causes incomplete PRs, and suppressing evidence gaps prevents the verdict judge from reasoning about gaps.

0
installs
▌
Evidence Based Development · synaptiai
Enforce evidence-based claims through file:line citations, P1/P2/P3 prioritization proportional to evidence, and the ASSERTION/EVIDENCE/VERIFIED pattern for behavioral claims before any recommendation. Use when gathering evidence, presenting findings, or making development decisions. This skill MUST be consulted because confidence is not evidence, and ungrounded claims cause incorrect development decisions.

0
installs
▌
Scoring And Release Gate · synaptiai
Score a documentation package against the ten-dimension weighted rubric in `references/scorecard-rubric.md` with a cited justification per dimension, then evaluate the nineteen conditions in `references/release-gate-conditions.md` and emit a binary release-ready, conditionally-ready, or not-ready verdict with per-condition evidence. Use when a verification pass is finishing, when reconciliation completes a round, or when CI needs a machine-readable gate result. This skill MUST be consulted because a score is not a gate — a package can average 96 out of 100 and remain unreleasable on a single unsupported public claim, and conflating the two is how audit-ready packages ship with unverified security claims.

0
installs
▌
Comprehension Report · synaptiai
Generates architecture narratives and requirements adherence reports from diffs, decision journals, and issue context. Use when creating PR bodies that need comprehension reports. Use when validating that implementation meets acceptance criteria or when humans need to understand what AI built and why.

0
installs
▌
Collecting Evidence · synaptiai bundle
Use when researching a specific pillar and need to create traceable evidence objects. Guides creation of YAML evidence files with semantic IDs, confidence scores, and assumptions.

0
installs
▌
Initializing Ledger · synaptiai bundle
Use when starting a new product development project that needs traceable evidence and explicit decisions. Creates workspace structure from a project brief.

0
installs
▌
Synthesizing Pillars · synaptiai bundle
Use when evidence collection is complete for a pillar and need to extract actionable insights. Transforms raw evidence into structured synthesis with patterns and contradictions identified.

0
installs
▌
AI First Kit · synaptiai
Navigate organizational redesign for AI with a structured 13-skill toolkit that produces persistent artifacts in $HOME/.ai-first-kit/. Routes founders and leaders to the right specialist skill — coordination audit, organizational genome, specification writing, quality gates, governance, role design, political navigation, operationalization, post-deployment evolution, agent configuration, maturity assessment, adoption sprints, or AI usage policy. Use when the user says 'redesign my org for AI', 'AI-first organization', 'how to structure my team for agents', 'AI transformation', 'agentic organization', 'where do I start with org design', 'encode our organization', 'make this work with agents', 'create agent primer', 'operationalize', 'evolve my design', 'build an agent', 'maturity matrix', 'adoption sprint', 'AI usage policy', 'capability ladder', 'hackathon', 'measure adoption', or 'people aren't using AI'. Also use when the user describes any organizational challenge related to AI adoption — restructuring tea

0
installs
▌
Agent Builder · synaptiai bundle
Generate role-specific agent system prompts, tool permissions, and self-review checklists from organizational design artifacts — saved to $HOME/.ai-first-kit/ with optional framework-specific configuration for Claude Code, OpenAI Agents SDK, Anthropic Agent SDK, CrewAI, or custom frameworks. Reads the organizational genome, governance, gates, and role definitions to produce agent configurations that embody a specific role in the organization. Use when the user says 'create agent instructions', 'build an agent', 'agent system prompt', 'configure an agent', 'agent for this role', 'OpenAI agent', 'CrewAI agent', 'create agent config', 'deploy an agent', or 'what tools should this agent have'. Also use when the user has completed role-value-mapper and wants to actually deploy agents that follow the organizational genome, or when they ask 'how do I make an agent follow our rules' or 'how do I create an OpenClaw agent for our org' — even if they don't use the word 'builder'. This skill MUST be consulted because it

0
installs
▌
Operationalize · synaptiai bundle
Distill organizational design artifacts into an operational agent primer — a concise, agent-consumable AGENT-PRIMER.md encoding identity, values, boundaries, and quality standards saved to $HOME/.ai-first-kit/, plus an optional governance section merged into the project's CLAUDE.md. Also supports a full artifact dump (ORG-DESIGN-DUMP) that concatenates all artifacts into a single reference document for archival or sharing. Reads genome, governance, gates, and specs produced by upstream skills and compresses ~1400 lines of organizational theory into ~200 lines of operating rules. Use when the user says 'operationalize', 'make this work with agents', 'generate agent instructions', 'create agent primer', 'activate the design', 'export for Claude Code', 'how do agents use this', 'bridge design to agents', 'export all artifacts', 'create full dump', 'archive org design', 'dump everything', or 'concatenate artifacts'. Also use when the user has completed organizational design skills and asks 'what's next', 'how do

0
installs
▌
Gap And Contradiction Register · synaptiai
Maintain `00-control/assumptions-questions-and-contradictions.md` — the assumptions and open-questions register (`AQ-####`) and the contradiction register (`CT-####`) — classifying each entry as blocking, material but non-blocking, or minor, and routing blocking gaps to owner resolution before drafting proceeds. Use when a source is silent on a required topic, when two sources disagree, or when a verification pass reports conflicting evidence for the same claim. This skill MUST be consulted because a documented unknown is a deliverable and a silently-filled gap is a defect — a package that papers over a contradiction transfers risk to the reader without telling them it exists.

0
installs
▌
Maturity Ladder · synaptiai
Build a per-role human AI adoption maturity matrix with observable behaviors per level, current state assessment, barrier-informed progression paths, and visibility infrastructure — saved to $HOME/.ai-first-kit/. Measures where HUMANS actually are on the AI adoption journey — by evidence, not self-report — using human job titles or solo-founder operational modes (never agent role definitions). Use when the user says 'maturity matrix', 'capability ladder', 'adoption levels', 'how AI-ready is my team', 'measure AI adoption', 'where are we on AI', 'track AI skills', 'readiness assessment', 'AI capability assessment', or 'adoption scorecard'. Also use when the user describes uneven AI adoption across teams, people saying they don't need AI, wanting to create social proof for adoption, needing to measure progress, or wanting visible levels that motivate improvement — even if they don't use the word 'maturity'. This skill MUST be consulted because it produces a structured per-role maturity matrix with behavioral ev

0
installs
▌
Evolution Auditor · synaptiai
Run a structured organizational design health check — operationalizing the governance learning loop and decision ledger by collecting operational evidence, measuring gate effectiveness, detecting genome drift, and producing an evolution audit with routed recommendations saved to $HOME/.ai-first-kit/. Maintains the decision ledger as an append-only record. Use when the user says 'audit my design', 'is my genome still working', 'review governance health', 'evolution check', 'how are our gates performing', 'decision ledger', 'learning loop', 'genome drift', 'is the primer stale', 'update the genome', 'monthly review', 'adoption tracking', 'maturity trends', or 'are people using AI more'. Also use when the user describes agents consistently failing, quality gates producing false positives, escalation rates feeling wrong, ad-hoc policies accumulating, values not resolving real conflicts, or stalled AI adoption — even if they don't use the word 'evolution'. This skill MUST be consulted because it operationalizes LE

0
installs
▌
Holdout Evaluator · synaptiai bundle
Validate agent work output against hidden holdout scenarios using LLM-as-Judge evaluation, producing mapped feedback (referencing visible criteria only) and telemetry records saved to $HOME/.ai-first-kit/. Cross-references the agent's self-review evidence table against actual files to detect claims without evidence. Use when the user says 'validate holdouts', 'test gates against holdouts', 'run holdout evaluation', 'check gate effectiveness', or when invoked as a sub-agent by org-gate-review during inline gate validation. Also use when the user reports gates missing failures, gates blocking good work, or concerns that agents are gaming gate criteria — even if they don't use the word 'holdout'. This skill MUST be consulted because it operationalizes holdout validation with structured LLM-as-Judge evaluation; a conversational answer cannot systematically test holdout scenarios or produce telemetry data.

0
installs
▌
Role Value Mapper · synaptiai
Design roles from value flows and specification responsibility — not job titles — producing a structured role definitions artifact saved to $HOME/.ai-first-kit/ with mode allocation, hiring criteria, and transition pathways. Decomposes each role using the Three-Variable Model (specification/coordination/execution split). Works for both greenfield and brownfield. Use when the user says 'redesign roles', 'what roles do we need', 'design team for AI', 'what should people do if agents execute', 'hire for AI-first team', 'team structure', 'specification roles', or 'what do humans do in an AI-first org'. Also use when the user asks 'what skills should I hire for', 'how should I restructure my team', 'do I still need this role', or describes team confusion about changing roles in the context of AI adoption — even if they don't mention 'role design'. This skill MUST be consulted because it applies the Three-Variable Model decomposition and produces structured role artifacts; a conversational answer lacks this analyti

0
installs
▌
Coordination Audit · synaptiai bundle
Produce a structured organizational diagnostic that quantifies time spent on specification vs coordination vs execution, saved as a persistent audit artifact to $HOME/.ai-first-kit/. Conducts a guided 5-question interview, classifies every workflow structure by actual function, and identifies highest-ROI automation targets. Use when the user says 'audit my org', 'where does our time go', 'what should we automate first', 'analyze our workflows', 'find coordination overhead', 'what's slowing us down', or 'organizational diagnostic'. Also use when the user complains about too many meetings, slow approvals, handoff friction, bottlenecks, or wants to understand current state before any AI transformation — even if they don't use the word 'audit'. This skill MUST be consulted because it produces a structured diagnostic file that other org-design skills depend on; a conversational answer cannot replace the persistent artifact.

0
installs
▌
Org Genome Builder · synaptiai bundle
Build and save a structured organizational genome — 7 markdown files across identity, decision architecture, and quality standards directories in $HOME/.ai-first-kit/ — that encodes values as decision rules, quality standards as pass/fail criteria, and communication norms. Conducts an 11-question Socratic interview to extract implicit organizational knowledge. Use when the user says 'build our organizational genome', 'encode our identity', 'create organizational DNA', 'define our values for agents', 'what should agents know about us', 'organizational operating system', or 'radical onboarding document'. Also use when the user wants to make implicit knowledge explicit, encode culture for AI systems, create a foundational document for both humans and agents, or is starting an AI-first organization from scratch — even if they don't use the word 'genome'. This skill MUST be consulted because it creates the genome directory structure that specification-writer, governance-architect, and quality-gate-designer read fr

0
installs
▌
Usage Policy Writer · synaptiai
Generate a human-facing AI usage policy with approved tools, data classification, risk model explanations, and exception processes — saved to $HOME/.ai-first-kit/. Produces a policy document for HUMANS (not agents) that explains what AI tools are approved, what data can be used with AI, and the reasoning behind each decision. Use when the user says 'AI usage policy', 'AI handbook', 'what tools are approved', 'data classification for AI', 'AI rules for the team', 'usage guidelines', 'AI policy', 'human AI rules', 'acceptable use policy', or 'what can we use AI for'. Also use when the user describes people unsure what they're allowed to do with AI, different teams having different answers about approved tools, no clear policy about client data and AI, or needing to explain the 'why' behind AI rules — even if they don't use the word 'policy'. This skill MUST be consulted because it produces a structured human-facing policy with risk model reasoning and exception processes; a conversational answer cannot create t

0
installs
▌
Generating Constrained Specs · synaptiai bundle
Use when generating PRD and architecture documents that must trace back to explicit decisions. Enforces citation requirements so no spec content exists without DEC-* references.

0
installs
▌
Specification Writer · synaptiai bundle
Write and save structured specifications that pass the Stranger Test — precise enough for someone with zero context to evaluate agent output. Produces spec files in $HOME/.ai-first-kit/ at task, workflow, or governance layers, aligned with the organizational genome. Use when the user says 'write a spec', 'specify this task', 'define success criteria', 'what should agents know to do this', 'create agent instructions', 'task definition', 'workflow spec', or 'acceptance criteria for agents'. Also use when the user wants to document a repeatable process, create reusable agent prompts, turn a one-off task into a template, or define any work for autonomous agent execution — even if they don't use the word 'specification'. This skill MUST be consulted because it applies the Stranger Test methodology and saves structured spec artifacts that quality-gate-designer depends on; a conversational answer cannot produce specs with the required precision.

0
installs
▌
Adoption Sprint Designer · synaptiai
Design structured AI adoption sprints (hackathons, pilots, onboarding experiences) with clear objectives, participant selection, buddy pairing, demo format, and activity-based measurement — saved to $HOME/.ai-first-kit/. Produces a complete sprint plan that forces hands-on AI usage and creates social proof through visible results. Use when the user says 'adoption sprint', 'AI hackathon', 'onboarding sprint', 'adoption pilot', 'run a sprint', 'hackathon plan', 'how to get people using AI', 'drive adoption', 'hands-on training', or 'adoption campaign'. Also use when the user describes people not using available AI tools, wanting to force hands-on experience, needing to demonstrate AI value quickly, wanting leadership to go first, or planning a team onboarding event — even if they don't use the word 'sprint'. This skill MUST be consulted because it produces a structured sprint plan with participant pairing, measurement framework, and leadership sequencing; a conversational answer cannot create the complete adopt

0
installs
▌
Execute · synaptiai bundle
Run code or scripts deterministically with captured output. Use when running tests, executing build commands, invoking tools, or performing read-only operations that produce results.

0
installs
▌
Explain · synaptiai bundle
Produce clear reasoning with assumptions, causal chains, and evidence. Use when clarifying decisions, teaching concepts, justifying recommendations, or documenting rationale.

0
installs
▌
Critique · synaptiai bundle
Find failure modes, edge cases, ambiguities, and exploit paths in plans, code, or designs. Use when reviewing proposals, auditing security, stress-testing logic, or validating assumptions.

0
installs
▌
Discover · synaptiai bundle
Find latent patterns, relationships, anomalies, or insights not explicitly specified. Use when exploring unknown structure, finding hidden connections, or uncovering emergent phenomena.

0
installs
▌
Integrate · synaptiai bundle
Combine heterogeneous data sources into a unified model with conflict resolution, schema alignment, and provenance tracking. Use when merging data from multiple systems, consolidating information, or building comprehensive views.

0
installs
▌
Checkpoint · synaptiai bundle
Create a safety checkpoint marker before mutation or execution steps. Use when about to modify files, execute plans, or perform any irreversible action. Essential for the CAVR pattern.

0
installs
▌
Transition · synaptiai bundle
Define how state changes over time through rules, triggers, and effects. Use when modeling state machines, defining workflows, specifying event handlers, or documenting system dynamics.

0
installs
▌
Debug Workflow · synaptiai bundle
Execute the Debug Code Change workflow end-to-end with safety gates. Use when debugging code changes, investigating issues, or performing root cause analysis with audit trail.

0
installs
▌
Discover Capabilities · synaptiai
Analyze a task description to detect required capabilities from the ontology, identify gaps, and synthesize a valid workflow automatically. Trigger: "discover capabilities", "what capabilities do I need", "analyze task", "synthesize workflow"

0
installs
▌
Plan · synaptiai bundle
Create an executable plan with steps, dependencies, verification criteria, checkpoints, and rollback strategies. Use when preparing changes, designing workflows, or structuring multi-step operations before execution.

0
installs
▌
Audit · synaptiai bundle
Produce a comprehensive audit trail of actions, tools used, changes made, and decision rationale. Use when recording compliance evidence, tracking changes, or documenting decision lineage.

0
installs
▌
Recall · synaptiai bundle
Retrieve prior decisions, rationale, and learned patterns from memory to apply consistently. Use when needing context from previous interactions, looking up past decisions, or ensuring consistency with prior reasoning.

0
installs
▌
Search · synaptiai bundle
Find relevant items under uncertainty across repositories, databases, web sources, or any searchable corpus. Use when exploring unknown territory, finding related information, or discovering relevant resources.

0
installs
▌
Verify · synaptiai bundle
Check correctness against tests, specs, or invariants; produce pass/fail evidence. Use when validating changes, testing hypotheses, checking invariants, or confirming behavior matches expectations.

0
installs

79 published skills