원클릭으로 Manus에서 모든 스킬 실행

ai-skills-init

Use this skill when bootstrapping a target repository to be ai-skills-aware — on the first run of any ai-skills workflow in a fresh repo, when adopting the ai-skills plugin in an existing repo, or after upgrading to a plugin version that adds new memory paths or templates, including when the user does not say "init" but asks to "set up" or "onboard" the repo — to detect codebase type, create CLAUDE.md + AGENTS.md scaffolding, initialize the .ai-skills-memory/ directory tree from L1 templates, and configure .gitignore. Idempotent — safe to re-run. Accepts `--codebase-type <type>` and `--overwrite`. Not for re-initializing only memory — use `/memory-init` instead.

Manus에서 실행

스타1

포크0

업데이트2026년 5월 18일 02:53

출처

alex-voloshin-dev

alex-voloshin-dev/ai-skills

GitHub 저장소 열기 Creator 저장소 보기

설치 명령

다운로드

Manus에서 실행

유용한 대상SOC

네트워크·컴퓨터 시스템 관리자컴퓨터 및 수학직15-1244L4

SKILL.md

readonly

이 저장소의 다른 Skills

같은 저장소

knowledge-sync-init

alex-voloshin-dev/ai-skills

Use this skill when bootstrapping scheduled knowledge-base sync for a repo that has no knowledge/.knowledge-sync.yml yet — to run one-time setup that detects the knowledge_root from CLAUDE.md/AGENTS.md, maps doc areas to source globs, records opt-in external sources (Linear/Notion/WebFetch, all disabled by default), captures a baseline last_scanned_sha, sets the per-area update policy, generates or seeds knowledge/CONVENTIONS.md, provisions the L4 memory dir, and offers to register the daily routine. Routes ongoing recurring sync operations to /knowledge-sync.

2026-05-231

knowledge-sync

alex-voloshin-dev/ai-skills

Use this skill when running the recurring (daily) knowledge-base rescan for a repo that already has knowledge/.knowledge-sync.yml — the main-thread dispatcher that reads the config, computes the git delta since last_scanned_sha, maps changed paths to affected doc areas, early-exits cheaply when nothing changed, then fans out one Agent(content-writer) per affected area, applies the propose/direct update policy, advances the baseline only on success, and writes an L4 run log — all with the G1 untrusted-content choke-point, secret-scan, deny-list, and budget controls woven in. For first-time setup use /knowledge-sync-init.

2026-05-231

memory-init

alex-voloshin-dev/ai-skills

Use this skill when bootstrapping memory in a freshly cloned repo or when upgrading from a pre-memory plugin version — to initialize the .ai-skills-memory/ skeleton in the current project (directory structure, .gitignore rules, learnings.md template, .committed/ allowlist). Idempotent — safe to re-run on a project that already has memory wired.

2026-05-231

feedback

alex-voloshin-dev/ai-skills

Use this skill when reviewing how the plugin behaved across recent runs, after a release to confirm reliability, before filing a plugin bug report, or when planning the next plugin improvement cycle — to collect and analyze past Claude Code session logs for the ai-skills plugin and surface agent, subagent, skill, command, and hook errors, timeouts, unexpected exits, and other anomalies that point at plugin defects. Defaults to the last 7 days of sessions for the current project. Produces an extended Markdown report on disk plus a brief on-screen summary.

2026-05-231

analyze-local

alex-voloshin-dev/ai-skills

Use this skill when a local container won't start, a service is unreachable from the host, a local docker-compose stack is misbehaving, or as the Docker-layer diagnosis step of a local bugfix flow — including when the user describes the symptom without naming Docker — to run a Docker-specific local diagnostic that collects container status, logs, networking, and resource usage and diagnoses issues, applying the SRE or DevOps role for investigation. For multi-scope environment analysis (Docker + Kubernetes + CI runner + drift snapshot + optional auto-fix) use `/env-analyze` instead.

2026-05-181

analyze-prod

alex-voloshin-dev/ai-skills

Use this skill when investigating a production incident, when an alert fires (latency spike, error rate, pod crashloop), when a customer-reported issue needs prod telemetry, or as the diagnosis step of an incident-response or production-bugfix flow — including when the user describes a prod symptom without asking to "analyze" — to analyze the production environment by collecting Kubernetes pod status, managed database health, logs, metrics, and networking and diagnosing issues, supporting GCP, Azure, and AWS via the `cloud-platforms` skill and applying the SRE or DevOps role.

2026-05-181

name	ai-skills-init
description	Use this skill when bootstrapping a target repository to be ai-skills-aware — on the first run of any ai-skills workflow in a fresh repo, when adopting the ai-skills plugin in an existing repo, or after upgrading to a plugin version that adds new memory paths or templates, including when the user does not say "init" but asks to "set up" or "onboard" the repo — to detect codebase type, create CLAUDE.md + AGENTS.md scaffolding, initialize the .ai-skills-memory/ directory tree from L1 templates, and configure .gitignore. Idempotent — safe to re-run. Accepts `--codebase-type <type>` and `--overwrite`. Not for re-initializing only memory — use `/memory-init` instead.
context	fork
argument-hint	[--codebase-type <type>] [--overwrite]

/ai-skills-init — Bootstrap a Target Repository

One-time (or re-runnable) setup for a target repo. Detects codebase type, scaffolds CLAUDE.md + AGENTS.md, creates .ai-skills-memory/ tree from L1 templates, appends .gitignore rules. Idempotent.

When to use

First run of any ai-skills workflow on a fresh repo
Adopting the ai-skills plugin in an existing repo (new for the team)
After upgrading the plugin to a version that adds new memory paths or templates

Not for

Re-initializing only memory (use /memory-init for that)
Modifying an existing CLAUDE.md (manual edit — this skill never overwrites without --overwrite)

Invocation

/ai-skills-init
/ai-skills-init --codebase-type python-flask
/ai-skills-init --overwrite                  # rare; only when CLAUDE.md is empty/stale

Arguments

Flag	Default	Effect
`--codebase-type`	auto-detect	`python-flask`, `python-fastapi`, `nodejs-express`, `nodejs-nextjs`, `astro`, `sveltekit`, `remix`, `nodejs-bun`, `deno`, `java-spring`, `kotlin-spring`, `kotlin-ktor`, `elixir-phoenix`, `go`, `ruby-rails`, `rust`, `dotnet`, `mixed`, `generic`
`--overwrite`	false	If `CLAUDE.md` already exists, OVERWRITE with fresh scaffold. Default: skip if exists

Output

<repo>/CLAUDE.md — scaffolded with codebase type, empty sections for user
<repo>/AGENTS.md — empty template (optional, for team customization of agents per-repo)
<repo>/.ai-skills-memory/ directory tree (per /memory-init spec)
<repo>/.gitignore — appended .ai-skills-memory/ exclusion rule (if not present)

Agent roster

Agent	Model	Effort	Tools	Role
`scaffolder` (internal — resolves to `software-engineer` with restricted tools)	haiku	low	Write, Read, Glob	Detects codebase type, generates scaffolds

Pipeline

┌─ Auto-detect codebase type:
│  └─ Check for: Pipfile, pyproject.toml, package.json, pom.xml,
│     build.gradle.kts, go.mod, Cargo.toml, Gemfile, mix.exs,
│     *.csproj, astro.config.mjs, svelte.config.js, remix.config.js,
│     bun.lockb / bunfig.toml, deno.json / deno.jsonc / deps.ts
│     Multiple matches → mixed; none → generic
│
├─ Generate CLAUDE.md scaffold:
│  └─ Sections: Overview, Tech Stack, Directory Layout, Key Decisions,
│     Constraints, Getting Started
│     Pre-fill: tech stack (detected), codebase type
│     Leave blank for user: business context, architectural decisions
│
├─ Generate (optional) AGENTS.md:
│  └─ List all plugin agents enumerated from `plugin/agents/`
│     (count auto-tracks future additions) with brief role descriptions
│     User can override / add per-repo customization
│
├─ Create .ai-skills-memory/ tree (delegate to /memory-init logic):
│  ├─ .gitignore (from plugin/memory/templates/ai-skills-memory.gitignore)
│  ├─ .committed/ subdir with README + allowlist-extensions
│  ├─ config.json (per-repo override stub for token caps + RALF caps)
│  ├─ learnings.md (empty template)
│  ├─ runs.jsonl, errors.log, redactions.log (touch-create)
│  └─ workflow subdirs: designs/, develop/, bugfix/, refactor/,
│     migrate/, spikes/, security-audits/, env-reports/, docs/
│
├─ Update root .gitignore:
│  └─ Add .ai-skills-memory/ rule (if not already present);
│     also add `.committed/` is tracked exception (negation rule)
│
└─ Print scaffold creation summary + next steps
   ("Fill business context in CLAUDE.md, run /feature-design or /develop")

No RALF — scaffolding is one-pass; idempotent so safe to re-run.

Codebase-type detection markers + template deltas

Type	Markers	CLAUDE.md template deltas
`astro`	`astro.config.mjs`; `package.json` has `"astro"` dep	Primary role: `frontend-engineer`. Note SSG/SSR/hybrid mode. Likely Tailwind / shadcn-ui. Playwright for E2E
`sveltekit`	`svelte.config.js`; `package.json` has `"@sveltejs/kit"` dep	Primary role: `frontend-engineer`. Note SSR/SSG modes. Tailwind / shadcn-ui likely. Playwright for E2E
`remix`	`remix.config.js`; `package.json` has `"@remix-run/*"` deps	Primary role: `frontend-engineer`. Note SSR-first full-stack. Tailwind / shadcn-ui likely. Playwright for E2E
`nodejs-bun`	`bun.lockb` or `bunfig.toml`	Use `bunx` over `npx`. Native TypeScript (no `tsc` step). Native test runner (`bun test`)
`deno`	`deno.json` / `deno.jsonc`; `deps.ts`	Use `deno run` / `deno test`. Built-in TS. Document the permissions model (`--allow-net`, `--allow-read`, …)
`elixir-phoenix`	`mix.exs` with `:phoenix` dep	Primary role: `elixir-engineer` (NOT `software-engineer` for stack-specific work). ExUnit for tests. `mix release` for deploy
`kotlin-spring`	`build.gradle.kts` + `kotlin` plugin + Spring deps	Primary role: `java-engineer`. Gradle Kotlin DSL. JUnit + Kotlin idioms
`kotlin-ktor`	`build.gradle.kts` + `io.ktor` deps	Primary role: `java-engineer`. Ktor coroutines model. H2 + Exposed common stack

Hard rules

Never overwrite CLAUDE.md without --overwrite — refuse with: "CLAUDE.md exists; pass --overwrite to replace"
pre-tool-use-committed-write.py hook applies to any .committed/ writes (committed-allowlist enforcement)
Idempotent — re-running on a fully-set-up repo is a no-op + report

Eval rubric

Pointer: plugin/eval/judge-rubrics/ai-skills-init.md (B10).

Dimensions:

Correctness — scaffold matches detected codebase type
Completeness — all expected directories and files present
Clarity — placeholder comments are helpful
No conflicts — respects existing CLAUDE.md if --overwrite not set
Gitignore safety — no important files accidentally ignored

Pass: avg ≥ 4.0, no dimension < 3.

Memory writes

Layer	When	Shape
L4	After complete	`.ai-skills-memory/init-summary.md` — timestamp, plugin version, codebase type detected, files created/skipped

Failure modes

Codebase type ambiguous (multiple stacks detected): scaffolder defaults to mixed; user can specify with --codebase-type
CLAUDE.md exists and --overwrite not set: skip CLAUDE.md creation; report exists; continue with /memory-init portion
Write permission denied: escalate to user with clear path; suggest checking repo writeability or running with elevated permissions
Plugin not installed properly (${CLAUDE_PLUGIN_ROOT} empty): error with: "Plugin templates not found. Verify plugin install with /plugin status ai-skills"

Observability events

workflow_start — ai-skills-init
codebase_type_detected — detected type
scaffold_created — files/dirs created (vs skipped)
workflow_end — COMPLETE

Integration

Reads templates from: ${CLAUDE_PLUGIN_ROOT}/memory/templates/ (7 files for memory skeleton). PII pattern file is at ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/pii-patterns.txt (loaded by hooks, not copied during init); project extension at .ai-skills-memory/.committed/pii-patterns.txt (created on demand).
Schemas: plugin/schemas/spawn-payload.schema.json (G7 — even though scaffolder is internal, payload still embedded for consistency)
Sub-workflow: /memory-init (the memory portion of the bootstrap)
Companions: /plugin-doctor (verify install before init), /context-load (after init, validate context loads correctly)
Rules: memory-discipline (write rules per layer), untrusted-content-wrapping (G1 wrap on existing CLAUDE.md if --overwrite reads it for backup)
Hooks: pre-tool-use-committed-write.py (committed-allowlist enforcement on .committed/ writes), session-start-context.py (will read newly-created CLAUDE.md on next session)