ono-sendai-labs

@ono-sendai-labs source repo

15 skills
0 followers
4 hours ago last updated

▌
Awo Orchestrator · ono-sendai-labs
Drive an implementation plan to completion with the awo workflow orchestrator. Loops over plan steps, generating code tasks per step and running the awo implementer/reviewer loop on each task, bookmarking every produced change for PR generation and keeping a work log. Handles an escalated task by repairing the specification and task file in a separate, auditable commit interposed below the implementation, then resuming awo in rework mode — never by silently patching the divergence in code.

0 installs
▌
Transcribing Audio · ono-sendai-labs bundle
Transcribe audio files (m4a, mp3, wav, aac, flac, ogg, etc.) containing spoken notes or recordings into text using the Gemini API. Use when the user provides an audio file and wants it transcribed, mentions spoken notes, voice memos, or dictated content that needs to be converted to text before further processing (e.g. drafting a document from spoken notes).

0 installs
▌
Simple Coding Project · ono-sendai-labs bundle
Start or bootstrap a small coding project end to end. Interview the user on requirements and design, write docs/requirements.md and docs/design.md, scaffold the repo (README, AGENTS.md with a CLAUDE.md symlink, LICENSE/NOTICE, .gitignore, justfile, source layout, docs/status.md), optionally set up GitHub CI, then implement milestone by milestone while keeping status notes current. Use when the user wants to start a new project or tool, turn an idea into a requirements/design doc and a working repo, or says things like "set up the repo", "write a requirements doc and sketch a design", or "create a justfile / AGENTS.md / README".

0 installs
▌
Task To Code · ono-sendai-labs bundle
Autonomously implement a code task using test-driven development, following an Explore, Plan, Code, Commit workflow. Takes a structured code task file (from plan-to-tasks or interactive-coding-task) and produces a complete, tested implementation in a described jj change. Escalates to the user only when blocked by issues that require revisiting the task, plan, or design.

0 installs
▌
Plan To Tasks · ono-sendai-labs
Generate structured code task files from an implementation plan. Processes one plan step at a time, breaking it into logical code tasks with acceptance criteria. Use when the user has an implementation plan (from design-to-plan or similar) and wants to generate code task files for the next step.

0 installs
▌
Design To Plan · ono-sendai-labs
Convert a detailed design document into a structured, incremental implementation plan with a progress checklist. Use when the user has a completed design document and wants to create an actionable implementation plan, or when transitioning from the interactive-design workflow to implementation.

0 installs
▌
Coco Contract Review · ono-sendai-labs
Review a component's contract — or a proposed contract change — for consistency in a coco component-contract codebase. Checks both that the implementation actually satisfies its own contract, and that the contracts of the components it depends on are strong enough to justify its own guarantees (compositional soundness — its rely-set is met). Also reviews a contract changeset from an evolution ripple for correct strengthening/breaking classification and completeness. Use when reviewing a contract, a proposed contract, or a commit that touches contracts; plugs into the structured-spec-to-code review phase (code-task-review, implementation-review). Reach for this whenever component contracts need to be checked for internal or compositional consistency.

0 installs
▌
Code Task Review · ono-sendai-labs bundle
Review jj changes produced by `task-to-code`. Supports initial reviews and re-reviews — a re-review is a fresh invocation that reads the prior review from disk and validates that its findings were addressed in the new change. Verifies acceptance-criteria coverage, test integrity (incl. detection of deleted/weakened tests), code style and LSP cleanliness on touched files, and security. Produces a structured YAML report that an orchestrator can use to route remediation back to the implementer.

0 installs
▌
Codebase Summary · ono-sendai-labs
Analyze a codebase and generate structured documentation describing system architecture, components, interfaces, and workflows. Use when the user wants to document, summarize, or understand a codebase's architecture, or generate a knowledge base for AI assistants to reference during development tasks.

0 installs
▌
Coco Component Design · ono-sendai-labs
Design and evolve software as components with contracts on their architecturally-visible interfaces (the "coco" component-contract discipline). Use this whenever the user asks to design a system or feature "according to the coco skills" / "using component contracts", when shaping an architecture into components with declared interfaces, dependencies, and authority, or when adding a feature to an existing contract-based codebase (which requires strengthening a contract and rippling the change to dependencies). Plugs into the structured-spec-to-code design phase. Make sure to reach for this skill for any component-boundary, interface-contract, or architecture-shaping design work under this discipline, even if the user doesn't say "coco".

0 installs
▌
Coco Contract Testing · ono-sendai-labs
Turn a component's contract into a test suite that provides evidence the implementation satisfies it, and build verified fakes for components that wrap stateful services (storage, RPCs). Use this during implementation of a coco component-contract codebase — when writing tests for a component whose behavior is specified by a contract, when a contract clause needs test evidence, or when a component needs an in-memory fake that must stay faithful to the real implementation. Plugs into the structured-spec-to-code implementation phase (task-to-code). Reach for this whenever contract clauses need to become tests or a fake must be shown to match the real thing.

0 installs
▌
Interactive Design · ono-sendai-labs
This workflow guides you through the process of transforming a rough idea into a detailed design document. It systematically refines your idea through interactive requirements clarification, research, and iterative design. Use when the user has a rough idea, feature concept, or project proposal that needs to be developed into a comprehensive design before implementation — whether for a greenfield project or adding features to an existing system.

0 installs
▌
Implementation Review · ono-sendai-labs bundle
Review an implementation as a whole — either a single completed step or a finished plan. Looks across every commit in scope, the current state of the codebase, the design, and the task-level review residue to surface architectural drift, duplication, undesirable dependencies, doc/code divergence, and cross-cutting issues that no single task review could catch. Produces a structured YAML report and a set of follow-on remediation `.code-task.md` files that re-enter the existing pipeline. Designed to run with clean context after the last task in scope is committed.

0 installs
▌
Interactive Coding Task · ono-sendai-labs
Interactively create structured code task files from rough descriptions, ideas, or ad-hoc requests. Use for smaller, well-scoped changes that don't need a full design-to-plan workflow — e.g., "address the TODO at auth.rs:45", "add input validation to the signup form", or "refactor the logging module to use structured logs".

0 installs
▌
Structured Spec To Code · ono-sendai-labs
Orchestrate the structured spec-to-code workflow — a pipeline that takes an idea from rough concept through design, planning, task generation, and implementation. Use when the user mentions "spec to code", wants to start or continue a structured development workflow, or asks where they are in the process. Also use when the user has an idea or project and you need to determine which stage of the pipeline to enter.

0 installs

15 published skills