cor-skills

skill
Guvenlik Denetimi
Uyari
Health Uyari
  • License — License: Apache-2.0
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Low visibility — Only 5 GitHub stars
Code Gecti
  • Code scan — Scanned 12 files during light audit, no dangerous patterns found
Permissions Gecti
  • Permissions — No dangerous permissions requested

Bu listing icin henuz AI raporu yok.

SUMMARY

COR (CodingOnRails): Think, Plan, Code, and other skills for AI coding agents

README.md

COR Skills

CodingOnRails — a methodological skill harness for AI coding agents.

Think before you research or plan. Research when current evidence matters. Plan before you code. Code until it's clean. Test only what you said you would.

Design

Agents can already write code. What they lack is a harness: structured thinking before planning, a confirmed plan before touching code, checks after every task, recoverable state when interrupted. Great frameworks exist for this — BMAD, Speckit, Superpowers. COR is just a different take: lighter, agent-agnostic, token-lean, and unopinionated on methodology. No TDD mandate, no rigid design phases — just the structure I actually want when I code.

There is also a meta dimension: the harness remembers. After each task, COR writes discovered gotchas and best practices back to your native instruction file — CLAUDE.md, AGENTS.md, Copilot instructions — whatever your agent already reads. Plain text, in your repo, yours to read and edit. No hidden memory, no black-box state. That transparency is deliberate: a developer who can see exactly what the agent knows stays in control, and that control is the foundation of good DX.

  • Agent-native — Claude Code, GitHub Copilot, Codex. Detects available tools at startup; adapts task tracking, question style, and plan storage per agent.
  • Crash-resilient — checkpoint written before any file is touched. Survives mid-task interruptions and context resets; resumes exactly where it stopped.
  • Lightweight — no added infrastructure. Structured workflow, not rigid one. No opinions on your stack, tooling, or memory setup.
  • Adaptable — stack-detected defaults you override at setup. Plan storage (markdown / memory / session) is your choice.
  • Transparent — gotchas and best practices written to your native instruction file after each task. Plain text you own; nothing hidden.
  • Token-efficient — token-caveman (in the toolbox plugin) cuts ~75% response verbosity without losing technical content.

Install

The repository is a plugin marketplace with two plugins:

Plugin Contents
cor The CodingOnRails workflow: setup, think, research, plan, code, test, work router, plus the design, review, refactor and docs phases
toolbox Standalone engineer helpers with no dependency on the workflow: show-me, token-caveman, authoring-skills, feature-map, feature-flag, feature-unflag, codebase-map, smart-commit

Any agent via the skills CLI (asks which skills and agents to install to):

npx skills add louisbrillet/cor-skills

Claude Code:

claude plugin marketplace add louisbrillet/cor-skills
claude plugin install cor@cor-skills
claude plugin install toolbox@cor-skills   # optional

GitHub Copilot CLI (also browsable from Customize in VS Code and the Copilot app):

copilot plugin marketplace add louisbrillet/cor-skills
copilot plugin install cor@cor-skills
copilot plugin install toolbox@cor-skills   # optional

Plugin skills are namespaced: /cor:cor-think, /toolbox:show-me.

Upgrading from 0.1 (flat skills/ layout)

Skills moved to plugins/<plugin>/skills/. Installed copies keep working, but npx skills update cannot resolve the old paths recorded in skills-lock.json. Reinstall once per project:

npx skills remove --all -y
npx skills add louisbrillet/cor-skills

To stay on the old layout: npx skills add louisbrillet/[email protected].

Skills

cor plugin

Skill Phase Status What it does
cor-setup Init stable Detects stack, configures checks and plan storage, optionally maps official dependency docs
cor-think 1 — Think stable Interrogates you with targeted questions, ends with a confidence summary
cor-research Optional stable Researches current libraries, APIs, and architecture practices, then saves an evidence-backed handoff for planning
cor-plan 2 — Plan stable Breaks the work into an ordered task list, saved to your chosen storage
cor-code 3 — Code stable Implements tasks autonomously, running all checks after each; pauses only when new information changes the approach
cor-test 4 — Test stable Runs only the tests that were planned — unit, integration, or UAT
cor-work Any stable Entry point: reads plan state and routes to the right phase automatically
cor-review Measure stable Measured code review (CRAP, duplication, mutation testing) judged by the refactor gates; ends in a refactor plan for cor-code
cor-docs After Code stable Updates Diataxis Markdown docs (MkDocs/Zensical) from a branch diff; edits only affected quadrants
cor-design Before Plan beta Exploratory UI design phase with variant generation, scoring, and hand-off into planning
cor-refacto Think + Plan deprecated Think+Plan workflow for behavior-preserving refactoring with strict simplification gates
ux-frameworks Any beta Layered UX diagnostics using Nielsen, Garrett, Gestalt/PARC, Morville, and Yablonski frameworks
ui-design-system-principles Any UI work beta Systematic UI design-token and accessibility principles for frontend output quality

toolbox plugin

Skill Status What it does
show-me beta Explains the current topic visually: pseudocode, call/component/file trees, Mermaid, diff sketches, or one HTML artifact
token-caveman stable Ultra-compressed response mode — cuts token usage ~75% by dropping filler while preserving technical accuracy
authoring-skills stable Authors and audits skills against the Agent Skills best practices; ships a validator script
feature-map beta Maps capabilities and features (entrypoints, modules per layer, tests, flags) of any codebase into docs/feature-map.md with Mermaid
feature-flag beta Plans gating a mapped feature behind a flag: detects or proposes the provider, picks the gate boundary, defines the contract, hands off to cor-code
feature-unflag beta Plans flag removal in keep-on, keep-off, or delete mode with a complete reference list and confirmed deletion set; hands off to cor-code
codebase-map beta Architectural map in docs/codebase-map.md: layers x slices import graph with violations, context view, capability overlay, health table
smart-commit beta Turns pending work into atomic commits grouped by intent, excludes secrets and build noise, matches the repo's message style

beta skills may change structure or behavior without backward-compatibility guarantees.

How it works

COR separates AI coding into four core phases plus optional Research between Think and Plan. You move through core phases in order; the agent does not skip ahead.

Think — Before any code is considered, the agent asks you structured questions across five areas: problem definition, scope, constraints, risks, and acceptance criteria. After each round of questions it produces a confidence summary (HIGH / MEDIUM / LOW per area). You decide when confidence is high enough to move on.

Research (optional) — When implementation depends on current external evidence, the agent inspects project versions and existing primitives, researches primary sources, compares viable options, and saves a cited .cor/research_<slug>.md handoff. It does not code or create plan tasks.

Plan — The agent takes everything surfaced in Think and relevant Research findings, then breaks it into an ordered, dependency-respecting task list. Test tasks are tagged explicitly ([unit], [integration], [UAT]). You review and confirm the breakdown before it's saved. Nothing is saved until you agree.

Code — The agent implements one task at a time without stopping for confirmation. After each task it runs every check command you configured (type-checking, linting, tests). If a check fails it fixes the root cause and re-runs — it never marks a task complete while checks are failing. Between tasks it writes notes to your agent instruction file (CLAUDE.md, AGENTS.md, or Copilot instructions) when something non-obvious was discovered, then commits the task (one commit per task, on by default; choose manual commits during setup to opt out).

Test — Works through any tasks tagged as tests. Unit and integration tests run the commands from your config. UAT tasks present the acceptance criteria and ask you to confirm manually.

Workflow

First time in a repo:

Invoke cor-setup. It scans package.json, tsconfig.json, Gemfile, etc. and proposes the right check commands for your stack. You confirm, adjust, pick where plans are stored, and can enable a committed map of official dependency docs for Node and Python projects.

Starting a new task:

Invoke cor-think — the agent asks you questions and produces a confidence summary after each round. When confidence is HIGH across all areas, you move on.

Optionally invoke cor-research when library choice, version-specific APIs, standards, or current architecture practice could change implementation. It saves a cited handoff under .cor/.

Invoke cor-plan — takes the thinking output and any applicable research handoff, then breaks it into an ordered task list. You confirm the breakdown before it's saved.

Invoke cor-code — picks up the first pending task and runs autonomously through the list: implement, run checks, fix failures, mark complete, repeat. It only pauses when a tool or command output reveals something that would materially change the approach (for example: a migration reveals the table already exists with a conflicting schema). Routine linter and test failures are fixed silently.

Invoke cor-test — works through any tasks tagged as tests.

Resuming mid-session:

Invoke cor-work — reads the plan, figures out where you are, and picks up from there. Works across sessions; if the agent was interrupted mid-task it detects the checkpoint and recovers cleanly.

Plan storage

During cor-setup you choose where task plans live:

  • Markdown — .cor/plan.md in the repo. Tracked by git, survives context resets. Best for team projects or anything long-running.
  • Memory — the agent's memory system. Loaded at session start, invisible in the repo. Best for solo, exploratory work.
  • Session — the agent's task panel (if supported). Resets on new session, best for short-lived work.

If you have multiple active plans (for example, two features in flight simultaneously), COR saves them as plan_1_auth_flow.md, plan_2_checkout_flow.md, etc. cor-code and cor-work list all plans with pending tasks and ask which one to work on.

Dependency documentation

For Node and Python projects, cor-setup can install an opt-in, version-aware documentation workflow. It adds .cor/scripts/gen-dependency-docs.mjs (with a docs:deps package script) or .cor/scripts/gen-dependency-docs.py (run through uv run, poetry run, or pdm run), and generated docs/DEPENDENCIES.md committed with code changes.

Agents consult this map before using third-party APIs. It prefers official llms.txt indexes, avoids loading full documentation without need, and treats lockfiles, installed typings, and package source as authoritative when online docs describe another version. Regenerate the map whenever direct dependencies or lockfiles change. CI may run the command then require no diff in docs/DEPENDENCIES.md.

Artifact canvas (GitHub Copilot, opt-in)

When GitHub Copilot is among the configured extensions, cor-setup offers an optional canvas extension (default: no). It installs .github/extensions/cor-artifacts/, which renders .cor/ plans as a live task board (progress, current checkpoint task, tasks ticking as cor-code works) and research reports as a navigable page. It is read-only: markdown stays the source of truth. Other agents ignore it. See How to view artifacts in Copilot.

COR artifact canvas: overview, research report, and plan tasks ticking live

Crash recovery

cor-code writes a .cor/checkpoint.md file before touching any code. It records the active plan path, the current task ID, and the phase (implementing, checks, or marking-complete). When the skill starts it checks for this file. If found and the phase is not done, it runs all configured checks to assess the situation and either resumes automatically or surfaces the state to you. When a task finishes cleanly the checkpoint is overwritten with phase: done — no file deletion needed.

If a checkpoint from a different plan is detected when starting work, cor-code pauses and asks whether to discard it or switch back to the interrupted plan first.

Notes

After completing each task, cor-code assesses what was discovered and appends a note to your agent instruction file if anything non-obvious happened: hidden constraints, surprising API behavior, architectural decisions, errors to avoid, or setup steps a future developer needs. Nothing is written if the task was routine. Notes accumulate as the project grows, building up a project-specific memory for the agent.

Stack support

cor-setup detects your stack and proposes sensible check defaults:

Stack Default checks
TypeScript + ESLint + Vitest tsc --noEmit, eslint --fix, vitest run
TypeScript + Biome tsc --noEmit, biome check --apply
Ruby on Rails rubocop -a
Python ruff check --fix, mypy
Go go vet ./..., go build ./...
Rust cargo check, cargo clippy

You can remove, modify, or add any command at setup time, or re-run cor-setup anytime.

Agent support

COR adapts its behaviour to the agent running it:

Agent Task tracking Questions
Claude Code TodoWrite AskUserQuestion (multiple choice)
GitHub Copilot todo_write / todo_read vscode_askQuestions
Codex / other .cor/plan.md directly Inline numbered list

All phases work across all three environments. The agent detects which tools are available at startup and uses the right ones throughout the session.

Documentation

Full documentation lives in docs/, organized with Diataxis (tutorials, how-to guides, reference, explanation). Preview with pip install mkdocs && mkdocs serve.

Skill quality

authoring-skills is the meta-skill governing this repo's own skills. It encodes the Agent Skills authoring best practices (frontmatter validity, description discoverability, the 500-line SKILL.md budget, one-level-deep references, progressive disclosure, workflows and evaluations) and ships a validator:

python plugins/toolbox/skills/authoring-skills/scripts/validate_skill.py plugins/*/skills/*/

Run it before shipping a skill change. ERROR findings must be fixed; WARN findings must be triaged explicitly.

Contributing

Issues are welcome; pull requests are reviewed on a best-effort basis. See CONTRIBUTING.md, the Code of Conduct and the security policy.

License

Apache-2.0

Yorumlar (0)

Sonuc bulunamadi