agentleFS
ice-lfernandesice-lfernandes/claude-spring-architect/.claude/skills/new-project/SKILL.md

new-project

Skill11 starsChanged yesterdayApache-2.0View on GitHub

Prepares a new Spring Boot project's generation without a clone of the source repository — fetches the source at its latest tag next to where the projects will live, records which ref and commit it fetched, and hands over to `/init-project` inside that tree. Runs from the plugin, in the directory that should hold the projects. Explicit invocation only.

52 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use checkpoint, prd and 9 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • genomewalkerSkill

    checkpoint

    Save a checkpoint of task status, decisions, active files, and next steps

    Also in 3 projects that use this

  • GitHubSkill

    prd

    Generate high-quality Product Requirements Documents (PRDs) for software systems and AI-powered features. Includes executive summaries, user stories, technical specifications, and risk analysis.

    Also in 3 projects that use this

  • sunnyclinches44Skill

    explain

    Explains code using real-world analogies and ASCII diagrams

    Also in 3 projects that use this

  • SentrySkill

    spec

    Produce a verified spec — problem, desired outcome, and acceptance criteria — before building. Use when given a GitHub/Linear issue link, when starting from a fuzzy in-conversation idea, or asked to "figure out what to do" / "scope this" / "what should I build" — whenever the *what* isn't yet pinned down. Grills the ambiguities, checks the premise against the code, and produces acceptance criteria you sign off on — then hands to design-first.

    Also in 3 projects that use this

  • SentrySkill

    review

    Fixture review skill.

    Also in 5 projects that use this

  • NVIDIASkill

    research

    Before designing a feature, research how comparable libraries solve the problem, check best practices, known pitfalls, and upstream changes. Use when starting a new feature, investigating an unfamiliar area, or the user asks to research something.

    Also in 5 projects that use this

  • +1 more from getsentry

The file

We split this skill into the rules it gives an agent

5 rules. 0 are common, 0 are distinctive, and 5 are very specific to this project.

  • 0

    Common

    Most of the 48 edited versions we read keep these.

  • 0

    Distinctive

    This author's own choices. Worth a look.

  • 5

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Follow § 2 of ${CLAUDE_SKILL_DIR}/../arch-adopt/SKILL.md — that section owns how the source is found, which ref is the default, and how its …

    line 43
  2. Very specific:

    Every other nerviz-* directory here is an earlier fetch.

    line 70
  3. Very specific:

    Run § 3 of ${CLAUDE_SKILL_DIR}/../arch-adopt/SKILL.md with the SRC of step 3, with one binding: its tarball is $TGZ, not $SRC.tgz.

    line 75
  4. Very specific:

    Read source.fetch_marker from $SRC/.claude/schemas/extensions.json — the fetched copy, never a path from memory — and write that file under …

    line 94
  5. Very specific:

    Leave commit out when step 2 resolved none.

    line 101

“Common” is measured: kept by at least 6 in 10 of the 48 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

New Project

Gets a person who installed the plugin to /init-project without a git clone. It fetches, records, and stops: the generation is not here. It runs in a second session, rooted at the fetched tree, through the same /init-project, project-initializer and project-bootstrap a clone runs — with that tree's hooks active — so a project made this way is the project a clone makes.

This session is rooted at the directory the person chose. Nothing of the fetched .claude/ is loaded in it: no init-project, no project-initializer, no guard, and every relative path project-bootstrap writes assumes the session root is the source. Following those files from here would be a different generation. Never do it, even when asked to "just continue".

Procedure

1 · Refuse where it cannot work

  • Outside the plugin. The path in step 2 still reads ${CLAUDE_PLUGIN_ROOT} literally → this copy is not the plugin's. In a clone of the source, /init-project is the command; say so and stop.
  • The JDK. java -version below 21, or no java → stop: the hooks and /init-project both run it. git and curl missing → stop, naming which.
  • Inside a project. The current directory holds pom.xml or build.gradle → stop. The fetched tree would land inside that project, and an existing project adopts with /nerviz:arch-adopt, not this.

2 · Resolve the source and the ref — arch-adopt § 2

Follow § 2 of ${CLAUDE_SKILL_DIR}/../arch-adopt/SKILL.md — that section owns how the source is found, which ref is the default, and how its commit is resolved. Three bindings, none of which changes what it does:

  • There is no project yet, so its third case is the one that applies: the plugin's copy is ${CLAUDE_PLUGIN_ROOT}/.plugin-source.json.
  • SRC for that section's own download is ${TMPDIR:-/tmp}/nerviz-new-project, set explicitly — its default names a directory arch-adopt may be using.
  • --ref from this skill's arguments passes through unchanged. --source does not exist here: a local checkout already is a clone.

What comes out: the ref, and the commit it names — or none, which § 2 says how to state.

3 · Choose the directory

SRC="$PWD/nerviz-<ref, every / replaced by ->"

The project is generated at ../<artifactId> of that tree — this directory — exactly as from a clone. Then, in order:

  1. $SRC exists and its own .claude/schemas/extensions.json names a source.fetch_marker file that records this same ref → reuse it, skip steps 4 and 5, and say "reused".
  2. $SRC exists otherwise → stop, and name it. Never delete, overwrite or merge into it.
  3. $SRC does not exist → step 4.

Every other nerviz-* directory here is an earlier fetch. List them in the report as safe to delete; never delete one.

4 · Fetch — arch-adopt § 3

Run § 3 of ${CLAUDE_SKILL_DIR}/../arch-adopt/SKILL.md with the SRC of step 3, with one binding: its tarball is $TGZ, not $SRC.tgz. SRC here is a directory the person owns, and a ~50 MB archive beside it would stay there, since this skill never runs rm. Replace both "$SRC.tgz" in that section with "$TGZ":

TGZ="${TMPDIR:-/tmp}/nerviz-new-project-fetch.tgz"

Then confirm the tree is a source and not an error page that happened to extract:

ls "$SRC/.claude/skills/init-project/SKILL.md" "$SRC/.claude/hooks/ArchHook.jar"

Either missing → stop, and say the ref holds no init-project.

5 · Record the fetch

Read source.fetch_marker from $SRC/.claude/schemas/extensions.json — the fetched copy, never a path from memory — and write that file under $SRC with Write:

{"ref": "<ref>", "commit": "<commit from step 2>"}

Leave commit out when step 2 resolved none. export reads this file when it writes the project's .claude/, and stamps that ref and commit; without it the stamp reads working-tree and unknown, since the tree is no repository. A fetched extensions.json with no source.fetch_marker is a ref older than the marker: write nothing, and say in the report that the stamp will read working-tree.

6 · Hand over

Print the report below and stop. Never start claude yourself, and never run /init-project in this session (top of this file).

Report

✅ <fetched | reused> — ref <ref> (<short commit | commit unknown>)

Source ....... <base_url host>
Tree ......... <$SRC>
Projects ..... generated here, at <this directory>/<artifactId>
Stamp ........ <ref and commit recorded | working-tree — this ref predates the fetch marker>
Older trees .. <none | the nerviz-* directories, safe to delete>

Next, in a terminal:
  cd "<$SRC>" && claude
Accept the folder's trust prompt: its hooks are what enforce the architecture during the
generation. Then, inside that session:
  /init-project
To approve the write outside that tree once, first: mkdir "<this directory>/<name>", then
/add-dir ../<name>. When it ends, develop in a new session inside the project:
  cd "<this directory>/<artifactId>" && claude

Failure modes

SymptomCauseWhat to say
The path in step 2 reads ${CLAUDE_PLUGIN_ROOT}Run from a clone, not from the pluginUse /init-project in the clone
curl: (22) on the tarballA private source and no token, or a ref that does not exist§ 3 of arch-adopt names the variable; check the ref with git ls-remote
$SRC exists with other contentA directory of the same name the person madeName it; they move or delete it — this skill never does
The stamp says working-treeThe fetched ref predates the fetch marker--ref with a newer tag, or accept it — /arch-adopt restamps on the first update
/init-project is unknown in the new sessionThe session was opened somewhere other than $SRCcd "<$SRC>" && claude

Why this is a manually-invoked skill

Form 2 (disable-model-invocation: true): it downloads a source tree into the person's directory, so it runs only when they ask for it by name — interview axis 2 of claude-code-architect-designer, a command typed by someone who has the plugin and no clone. The closest rejected form was generating inline from the fetched tree, in this session: nothing of that tree loads here, so parity with /init-project would rest on the model translating every path, and a project that differs from what a clone generates was the one outcome the interview ruled out. Runs on sonnet with effort: low: it follows arch-adopt's fetch, writes one small file and prints.

Contract

Class: ops — the territory is skill_classes.ops in .claude/schemas/extensions.json, and it is empty: this skill writes nothing in the session's project. What it writes lands outside it, in the fetched tree.

Unfiltered Bash: the fetch is arch-adopt § 3's — curl with an optional header array, mkdir and tar chained — plus git ls-remote and java -version; scoped rules would not match those compound lines. It never runs rm, never runs claude, and never runs the fetched ArchHook.

Reads ${CLAUDE_PLUGIN_ROOT}/.plugin-source.json, § 2 and § 3 of arch-adopt (cited, never copied — the plugin ships both), and the fetched extensions.json's source block.

Writes nerviz-<ref>/ in the current directory — the extracted tree — and the fetch marker inside it. Nothing else, and never over an existing directory.

Never travels. A creation skill: it serves only before a project exists, so it is in export.skills.exclude like init-project and project-bootstrap. The plugin vendors it.

Hands off to /init-project, in a session the person opens in the fetched tree.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.