init
Onboard a Go repository to Atom: capture its initial baseline or confirm existing setup without changes. Keywords: init, onboard, setup, install atom, bootstrap, add atom to this repo.
- License 许可
- MIT
- 最近更新
- 2026-11-13
- Stars
- ★ 0
- Forks
- 0
01 前言 Front Matter
- name
- init
- description
- Onboard a Go repository to Atom: capture its initial baseline or confirm existing setup without changes. Keywords: init, onboard, setup, install atom, bootstrap, add atom to this repo.
03 SKILL.md 正文
/atom:init
Set up a Go repository, or confirm an existing matching setup without changes.
When to use
- Adding Atom to a repository for the first time
- Confirming that an already onboarded repository needs no changes
- Diagnosing missing or corrupt onboarding without silently repairing it
- Verifying the toolchain before starting a pipeline
Step 1 — Confirm this is a Go repository
Atom is Go-scoped. It needs a go.mod.
If there isn't one, stop and ask the developer whether to create a module or whether Atom is the wrong tool here. Do not invent a module path.
Step 2 — Bootstrap the command
Check the active session's client identity against the supported minimum in bootstrap.md, not the version of another executable. If it is unknown, conflicting or unsupported, ask one focused clarification or switch/update question and wait; do not update automatically. Resolve Go's availability before invoking it. If missing, explain the prerequisite and ask the developer to supply it before continuing; do not install Go or run extra version/build checks instead of the baseline.
Follow bootstrap.md. It establishes working forms
for both atom and atom-write-artifact without replacing an installed package.
Read it before executing discovery commands. Reuse forms already verified for
this session/environment; otherwise check availability before help or module calls.
Missing tools are a setup decision: explain what is absent and ask before any
installation. Healthy tools outside PATH are reused, not reinstalled. A found but
broken/partial/unsafe installation is preserved and reported, not silently repaired.
Group compatible read-only prerequisite checks into as few terminal invocations as safely possible, while following bootstrap's order and stop conditions. If a group cannot preserve a check's result or required decision, run it separately.
Keep actual command statuses and relevant diagnostics; never truncate help/writer
output with head or hide a failure behind a successful wrapper. A writer refusal
or nonzero result stops the workflow, even if the wrapper reports zero. Do not probe
an invalid writer target, continue with another write or bypass it with an editor.
Bootstrap approval does not approve later init or module-local artifact writes.
On Windows, keep working module forms when entry points are hidden; do not ask about
changing PATH during normal init. If the developer requests PATH setup, bootstrap
provides the one-time setup-path opt-in. After successful setup, use its printed
absolute executable commands in this session. Do not re-probe command names or ask
again to locate the same executables.
Do not locate or read Atom's Python source while onboarding another repository.
Use the command forms established by bootstrap from the target module directory;
use --help when an option is unclear, not the implementation in an external
checkout or installed package.
Existing .atom/ files do not require an implementation audit. Read the named local
files in steps 4 and 5 and report any discrepancy. If atom init refuses because
existing setup is conflicting, incomplete, or corrupt, preserve it and report the
named problem; do not add --force
without the developer's explicit approval to discard that state.
Step 3 — Run deterministic onboarding
atom init
On a valid matching repeat, this command returns 0 with an explicit read-only no-op message. It does not refresh the baseline, detect build commands again, reset approvals, update the local bundle, append events, or change files and timestamps.
An existing .atom/ with conflicting, incomplete, or corrupt setup returns a nonzero
error without repair. Restore or repair the named files before retrying. Explicit
--force deliberately resets the project record and discards recorded approvals; it
is not a workaround for a normal repeat.
On first initialization, this one command performs the operations that must agree:
- runs the untouched no-race baseline before writing Atom files;
- records the exact result in
.atom/baseline.json, including failures; - infers the module path and records the verified build/test commands;
- prefers the repository's own
make build/make testwhen a Makefile defines them; - creates the project scaffold and installs the local instruction bundle.
On first initialization it creates:
.atom/
atom/ # self-contained local instructions and skills
config.json # module path, build/test commands, model roles, coverage target
state.json # pipeline + phase state
events.jsonl # structured event log
baseline.json # the pre-Atom check result
specs/ # pipeline artifacts
poc/ # throwaway spikes
If the printed baseline is failing, tell the developer immediately. Do not repair the repository during onboarding unless asked. A pre-existing failure discovered three phases later looks like something Atom caused.
Maintains a marked block in .gitignore for machine-local runtime data:
.atom/baseline.json, .atom/events.jsonl, and .atom/events.lock. Existing ignore
rules are preserved. .atom/config.json, .atom/state.json, and .atom/atom/**
remain tracked because they are shared project configuration, approvals, and
instructions.
Ignore rules do not untrack files already committed. If Git already tracks one of
these generated files, tell the developer to remove that specific path from the index
with git rm --cached <path> after confirming it is safe; never run the command
silently or untrack the whole .atom/ directory.
specs/ and poc/ are committed — they are the reviewable record of how the code
came to look the way it does.
Step 4 — Confirm the recorded commands
For first initialization, read .atom/config.json and confirm the module, build
command, and test command match the baseline that atom init printed. Do not rewrite
the file through a generic edit tool; a mismatch is an onboarding defect to report.
For a successful no-op, report the preserved configuration. No new baseline was run, so do not compare commands to a newly printed baseline or claim they were reverified.
A repository with a Makefile will show make build and make test rather than the Go
defaults, and atom init prints the reason it chose them. This is expected, not a
defect: the project's own build usually carries tags, ldflags or generation steps that
go build ./... would silently skip. Targets are resolved one at a time, so a Makefile
with only build correctly leaves the test command Go-native. If make is not
installed, Atom says so and stays on the Go defaults rather than running a command that
cannot work.
Step 5 — Confirm the local instructions
On first initialization, atom init copies instructions, references, templates and
skills into .atom/atom/. It also creates or updates
.github/copilot-instructions.md with a relative link to that local bundle.
Nothing in the target repository should point back to the Atom checkout or an
installed-plugin directory.
If the repository already has Copilot instructions, atom init preserves them and
adds the managed local reference once.
Keep verification approval-free
After first initialization, verify onboarding by reading these named files:
.atom/config.json.atom/baseline.json.atom/atom/manifest.json.github/copilot-instructions.md.gitignore
After a successful no-op, the same shared-file reads are sufficient without
.atom/baseline.json: machine-local baseline and event files may be absent on a clone.
Do not recreate them or require empty specs/ and poc/ directories to be restored.
The no-op validates shared onboarding structurally, not the installed bundle's version
or every instruction's content.
Do not run git status, recursive shell scans, or another Atom command on the normal
success path. The init output plus these file reads prove the contract without asking
the developer for more shell approvals. Run a follow-up command only when the init
output or one of these files exposes a specific discrepancy.
Step 6 — Report
Tell the developer:
- For first initialization: the baseline result, including every failed gate, and what was created
- For a no-op: setup was already valid, nothing changed, and no baseline was refreshed
- The two established command forms, once, for reuse in subsequent beats
- The recommended model setup — see model-guidance.md
- For first initialization: next step
/atom:discover; for a no-op: resume the existing workflow, using/atom-statusif its position is unclear
Use the appropriate skill available in the active client. If a documented alias is unknown or rejected, disclose that rather than guessing another alias or reinstalling the plugin. Naming the intended skill in ordinary language does not prove a slash alias works; invoke that skill, not a silently substituted beat.
Done when
- [ ]
go.modconfirmed - [ ]
atom initcompleted - [ ] First init: no-race baseline captured before any Atom file was written
- [ ] First init:
.atom/,specs/,poc/created;.gitignoreupdated - [ ] First init: config commands match the commands exercised by the baseline
- [ ] Repeat: valid matching setup confirmed without changes or a new baseline
- [ ] Local Atom bundle present under
.atom/atom/ - [ ] Repository agent instructions reference the local bundle
- [ ] Developer briefed, including model guidance
Next
First initialization: /atom:discover. Successful no-op: resume the existing workflow.
04 同仓库更多 Skills
tdd
Implement one phase test-first in Go: red, green, refactor, against an approved design spec. Keywords: TDD, test driven, test first, implement, red green refactor, build the phase, write the code.
spec
Write the high-level design spec for one phase, grounded in that phase POC evidence. Keywords: spec, design, design doc, architecture, API design, describe the approach.
ship
Commit, push and open a pull request for a completed phase, with the pipeline artifacts linked. Keywords: ship, PR, pull request, commit, push, open a PR, submit.
review
Standalone or phase multi-model review of a Go diff, merged into one report with severities. Keywords: review, code review, multi-model review, review my changes, review the diff, critique.
poc
Build, run and evaluate a throwaway Go spike that answers one falsifiable question. Produces a POC Report with verbatim evidence. Keywords: POC, proof of concept, spike, prototype, prove it, experiment, try it out.
plan
Break proven work into ordered, independently shippable phases based on POC evidence. Keywords: plan, phases, break down, roadmap, decompose, milestones, sequencing.