Agent skill

Adr Writing

by lablup in lablup/backend.ai-webui

Write and revise the ADRs in docs/adr/ and their index docs/ARCHITECTURE.md so a first-time reader understands them alone.

LGPL-3.0Auto-check passedDevelopment

Install Adr Writing

skills CLI
$ npx skills add lablup/backend.ai-webui --skill adr-writing -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install lablup/backend.ai-webui adr-writing --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/lablup/backend.ai-webui.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/adr-writing .claude/skills/adr-writing && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
adr-writing
GitHub stars
133
Token cost
~2k tokens
SKILL.md length
1,122 words
Files
4 (incl. references)
Skills in repo
13
Repo updated
First seen
Licence
LGPL-3.0

At a glance

Write and revise the ADRs in docs/adr/ and their index docs/ARCHITECTURE.md so a first-time reader understands them alone.

  • Works in 5 steps: Gather what the document must agree with → Draft against the rule catalogues → Reread as a first-time reader → …
  • Architecture decision record
  • SKILL.md covers What an ADR is for, ADR file conventions, Phase 0 — Gather what the… and Phase 1 — Draft against the…, plus 3 more sections
  • Calls git

What it does

Adr Writing is an agent skill from lablup/backend.ai-webui. Write and revise the ADRs in docs/adr/ and their index docs/ARCHITECTURE.md so a first-time reader understands them alone. Covers the file conventions (name, title, no status field, how a decision is retired), the section skeleton, the writing rules for titles, terms, and sentences, mermaid usage and its syntax traps, and the checks a document passes before it lands. Use before authoring a new ADR, before revising one, and before landing any change under docs/adr/. Trigger on "ADR 써줘", "결정 기록 남겨줘", "write an…

Its SKILL.md is about 2k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including reference files (for example `agents/openai.yaml`, `references/document-shape.md` and `references/writing-rules.md`).

It sits in Development, covering Architecture decision records. It works with Mermaid. The repository describes itself as: Backend.AI Web UI for web / desktop app (Windows/Linux/macOS). Backend.AI Web UI provides a convenient environment for users, while allowing various commands to be executed… The licence is LGPL-3.0.

When your agent uses it

  • Architecture decision record
  • An implementation needs a decision no ADR in force covers

Example prompts

  • “ADR 써줘”
  • “write an ADR”
  • “architecture decision record”
  • “/adr-writing”

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Gather what the document must agree with
  2. Draft against the rule catalogues
  3. Reread as a first-time reader
  4. Adversarial review before landing
  5. Land

What it can do on your machine

Read from SKILL.md and the folder at commit 10554dc. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Adr Writing loads about 2k tokens when it runs, and up to ~5.8k if it reads all its reference files. Until then it costs about 183 tokens; SKILL.md has 1,122 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~183
When it runs · the whole SKILL.md, loaded when a task matches
~2k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~5.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from lablup/backend.ai-webui at commit 10554dc, republished under its LGPL-3.0 licence (© lablup). 1,122 words, ~1,988 tokens.

Download SKILL.mdSave it as .claude/skills/adr-writing/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
adr-writing
description
Write and revise the ADRs in `docs/adr/` and their index `docs/ARCHITECTURE.md` so a first-time reader understands them alone. Covers the file conventions (name, title, no status field, how a decision is retired), the section skeleton, the writing rules for titles, terms, and sentences, mermaid usage and its syntax traps, and the checks a document passes before it lands. Use before authoring a new ADR, before revising one, and before landing any change under `docs/adr/`. Trigger on "ADR 써줘", "결정 기록 남겨줘", "write an ADR", "architecture decision record", or when an implementation needs a decision no ADR in force covers. When a change needs an ADR, and what an agent owes the ADRs in force, is `.claude/rules/adr.md`.

ADR writing

A decision nobody can read was not recorded. This skill governs the shape of every file under docs/adr/ and of docs/ARCHITECTURE.md: how the file is named and retired, how the sections run, when to draw instead of explain, and what must hold before the document lands. When a change needs an ADR and what an agent owes the ADRs in force is .claude/rules/adr.md, loaded in every session; this skill does not repeat it.

Every sentence must pass one test: would someone meeting this codebase for the first time understand it without asking a question? If not, the fix belongs in the writing, not in the reader.

What an ADR is for

An ADR records an architecture-level decision: what was chosen, which alternatives were dropped and why, and what shape the code must now take. The reader is an agent or a person who will build against this decision months from now, not the author and not today's reviewer.

  • Enough context, and no more. A line survives only if that reader would act differently for having read it.
  • Never narrate your thinking. Deliberation, reversals, what an earlier draft said, what you worried about — none of it belongs. State the fact, the option, or the decision.
  • The document never talks about itself. No "covered in the last section", no "this document does not decide X". Say the thing or delete it.
  • Link outward instead of retelling. When the context lives in another ADR, a source file, a Jira issue, or an upstream document, cite it and reproduce only the sentence the reader must act on.
  • Name the scope boundary once. What is out of scope gets one line — never the reasoning for deferring it, never a sketch of the deferred design.

After reading, does the reader know what was chosen, what was rejected, and what shape the code must take? If any of the three is missing it is a memo, not a decision record.

ADR file conventions

This is the definition of how an ADR file is named, titled, and retired. The one other copy is .github/instructions/adr.instructions.md, which restates the points Copilot needs because it cannot load a skill; keep the two in step.

  • Filename — NNNN-title.md, for example 0001-explicit-project-prop-contract.md. The next number is the highest NNNN in docs/adr/ plus one. Numbers are never reused, so when the sequence has a gap the deleted number stays retired; git log -- docs/adr shows it.
  • Title — # NNNN — <English noun phrase> (T1–T6). A Jira key goes in the sources section, never in the title. A supersede pointer goes on its own line, never in the title.
  • No status field. An ADR on main is a decision in force — landing it there, merged and human-approved, is the record. A draft under review is proposed by virtue of sitting in an unmerged PR, and nothing marks it in the file. The one marker a file ever carries is reversal.
  • Reversing a decision — do not edit the existing ADR's reasoning. Either keep the file and add a top line > superseded by NNNN naming what replaced it, or delete it outright. Both are allowed, and deleting is usually right once the decision and the code it described are both gone, because a retired file is then a trap a reader has to disprove. Git history holds what it said. Convert inbound references in surviving documents and source comments to plain ADR NNNN mentions.
  • Partial replacement — if the new ADR replaces only part of the old, keep the old file, say so in the new ADR, and add a scoped pointer line rather than the blanket supersede marker.
  • Mention form — documents and PR bodies write ADR NNNN. Source comments written before this convention say ADR-NNNN; they are corrected when the file is next edited, never swept.
  • Language — the title is English; the body is Korean, with English technical terms and identifiers written as they appear in the code. An ADR that landed before this convention keeps its body language; a document is revised only when its content changes, never translated for its own sake. Section headings follow the body language, as references/document-shape.md fixes.
Show full SKILL.md (438 more words)Show less

Phase 0 — Gather what the document must agree with

Read these before writing, so the draft does not contradict what already landed.

  • The ADRs this decision touches, including the ones it supersedes or narrows, and their rows in docs/ARCHITECTURE.md.
  • The source files the decision names, so identifiers in the text match the code — component names, hook names, atom names, ESLint rule ids.
  • The Jira issue the work belongs to, so the sources section can cite it.
  • Sibling ADRs written in the same increment, so terminology stays shared.

Phase 1 — Draft against the rule catalogues

Two reference files hold the rules, and both cite by id — "T1 violation", "fixed S4", "D2 missing".

fileidswhat it governs
references/writing-rules.mdT1–T6, L1–L5, S1–S10, D1–D2the title, the terms, the sentences and bullets, the Summary a body opens with, and the diagram a flow gets
references/document-shape.mdD3–D4the section skeleton, the heading language, the increment overview, the one-diagram floor, and the mermaid syntax traps

Write the sections in the order D3 fixes: title, Summary, Context, diagrams, Decision, alternatives with the reason each was rejected, Consequences, sources, glossary.

Phase 2 — Reread as a first-time reader

Work the reread list at the end of references/writing-rules.md, then these three checks, which only a document can fail:

  • A sibling document draws the same components with a different decomposition (D2), or the increment has no overview document (D4).
  • A section from the D3 skeleton is missing, or a heading is in the wrong language for the body.
  • A Decision item stacks several decisions that should be ### N. subsections.

Phase 3 — Adversarial review before landing

Self-review does not catch narration: the author cannot see their own. Before landing, dispatch one reviewer agent with the document path and this instruction, and fix everything it returns. Ask for defects, not a verdict:

  • Padding. Every line a reader building from this would not act on — narrated thinking, restatements, deferral rationale, the document describing itself — with its line number.
  • Gaps. What an agent implementing against this would still have to ask: a chosen shape with no type, no prop contract, no invariant, no file it lives in.

Verify the findings before acting — a reviewer that is wrong about the code is common. Check the file it cites.

Phase 4 — Land

  • Read the document once on GitHub's rendering of the branch. A broken mermaid diagram shows there as a syntax error; no CI check catches it.
  • Add or update the ADR's row in docs/ARCHITECTURE.md in the same change.
  • Verify every cross-reference resolves to a file that exists, and when an ADR was retired, grep for its filename so no link points at it.

© lablup, LGPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (references) in .claude/skills/adr-writing of lablup/backend.ai-webui.

  • SKILL.md
  • agents/openai.yaml
  • references/document-shape.md
  • references/writing-rules.md

Open the folder on GitHubat commit 10554dc

Compare with similar skills

Adr Writing next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Adr Writing compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Adr Writing this skilllablup/backend.ai-webui133—~2kAutomated safety check: PassLGPL-3.0
Design Doc MermaidSpillwaveSolutions/design-doc-mermaid1751 repos~5.6kAutomated safety check: PassNone
Architecture Decisions and ADRsfirst-fluke/oh-my-agent1.3k—~2.6kAutomated safety check: PassMIT
Docs Architecturejh941213/my-cc-harness126—~923Automated safety check: NotesNone
Create PRSmana/cloud-native-ref103—~1.2kAutomated safety check: PassApache-2.0
Senior Architectalirezarezvani/claude-skills28k4 repos~2.7kAutomated safety check: PassMIT

Similar skills

  • Design Doc Mermaid

    SpillwaveSolutions/design-doc-mermaid

    Create Mermaid diagrams (flowchart, sequence, class, ER, state, C4, architecture) from text or source code.

    175 GitHub starsUsed in 1 repo~5.6k tokens
    DevelopmentAuto-check passed
  • Architecture Decisions and ADRs

    first-fluke/oh-my-agent

    Evaluates system boundaries and tradeoffs and writes architecture recommendations, option comparisons or ADRs, with a Mermaid diagram when structure changes.

    1.3k GitHub stars~2.6k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Docs Architecture

    jh941213/my-cc-harness

    Generate/update architecture docs — ARCHITECTURE.md (codemap), architecture diagrams (C4 mermaid), ADRs (MADR), data model ERD.

    126 GitHub stars~923 tokensUpdated 2 mo ago
    DevelopmentAuto-check: notes
  • Create PR

    Smana/cloud-native-ref

    Create or update a Pull Request with AI-generated description, mermaid diagram, file walkthrough, and automatic design-doc detection.

    103 GitHub stars~1.2k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Senior Architect

    alirezarezvani/claude-skills

    This skill should be used when the user asks to "design system architecture", "evaluate microservices vs monolith", "create architecture diagrams", "analyze dependencies", "choose a database", "plan…

    28k GitHub starsUsed in 4 repos~2.7k tokens
    DevelopmentAuto-check passed
  • PR Body Drafter

    Yeachan-Heo/oh-my-claudecode

    Drafts a pull request body from the session's paper trail: a one-line claim with the smallest proving visual, verify evidence, a reversibility note and glossary terms.

    40k GitHub stars~773 tokensUpdated today
    DevelopmentAuto-check passed

More from lablup/backend.ai-webui

All 13 skills in this repo
  • Walkthrough

    lablup/backend.ai-webui

    Mint a walkthrough for the PR this session just implemented: a set of numbered stops a reviewer opens in the live dev server, each one marking an element on screen with what changed and what to check.

    133 GitHub stars~4.9k tokensUpdated today
    Auto-check: notes
  • Docs Lead

    lablup/backend.ai-webui

    A skill your agent uses whenever the user mentions docs, the manual, documentation, terminology, translations, or screenshots — including indirect mentions like "이 PR 문서 영향 봐줘", "문서 점검", "용어 통일"…

    133 GitHub stars~2.9k tokensUpdated today
    Auto-check passed
  • Backend AI Guide

    lablup/backend.ai-webui

    Expert guide for Backend.AI distributed computing platform. An agent skill from lablup/backend.ai-webui.

    133 GitHub starsUsed in 1 repo~1.8k tokens
    Auto-check passed
  • Dev Server

    lablup/backend.ai-webui

    Start the project's development server (pnpm dev for backend.ai-webui; discovered from README/package.json elsewhere), deriving the header color, app name, default backend endpoint and login…

    133 GitHub stars~6.9k tokensUpdated today
    Auto-check: notes
  • Record E2E Gif

    lablup/backend.ai-webui

    Record Playwright e2e tests as one GIF per test case (video → ffmpeg palette GIF) and return a markdown table for a PR description.

    133 GitHub stars~907 tokensUpdated today
    Auto-check: notes
  • Relay Mutation Store Updates

    lablup/backend.ai-webui

    A skill your agent uses when writing if (success) updateFetchKey(), an onRequestClose handler, or any refetch after a mutation; when a setting modal handles both create and update behind one…

    133 GitHub stars~2.8k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Adr Writing

What does Adr Writing do?

Write and revise the ADRs in docs/adr/ and their index docs/ARCHITECTURE.md so a first-time reader understands them alone. ai-webui.md so a first-time reader understands them alone.

When should I use Adr Writing?

Adr Writing fits situations like: architecture decision record; an implementation needs a decision no ADR in force covers.

How do I install Adr Writing in Claude Code?

Run `npx skills add lablup/backend.ai-webui --skill adr-writing -a claude-code`. Or copy the skill folder (.claude/skills/adr-writing in lablup/backend.ai-webui) into .claude/skills/adr-writing in your project. Claude Code loads it when a task matches its description.

How do I install Adr Writing in Codex?

Run `npx skills add lablup/backend.ai-webui --skill adr-writing -a codex`. Or copy the skill folder (.claude/skills/adr-writing in lablup/backend.ai-webui) into .agents/skills/adr-writing in your project. Codex loads it when a task matches its description.

Can I use Adr Writing in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add lablup/backend.ai-webui --skill adr-writing -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/adr-writing, .gemini/skills/adr-writing, .github/skills/adr-writing and .opencode/skills/adr-writing in your project.

What does Adr Writing need to run?

Going by SKILL.md and its folder, Adr Writing needs the command-line tools its instructions call (git).

Does Adr Writing access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Adr Writing safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Adr Writing use?

Adr Writing is published under the LGPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Adr Writing use?

About 2k tokens (SKILL.md is roughly 8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.8k tokens, read only when the agent opens those files.

What are the alternatives to Adr Writing?

Skills that share tags, products or a category with Adr Writing: Design Doc Mermaid (SpillwaveSolutions/design-doc-mermaid, 175 stars), Architecture Decisions and ADRs (first-fluke/oh-my-agent, 1.3k stars), Docs Architecture (jh941213/my-cc-harness, 126 stars) and Create PR (Smana/cloud-native-ref, 103 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Adr Writing?

lablup (a GitHub organization) maintains it in lablup/backend.ai-webui, which has 133 GitHub stars. The repository holds 13 skills in this directory. The repository was last updated on October 7, 2026.

Source: lablup/backend.ai-webui on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.