# generate-project-skill

Adopt this skill: https://proskills.md/skills/other/skilld-dev-skilld-skills-generate-project-skill

Page: https://proskills.md/skills/other/skilld-dev-skilld-skills-generate-project-skill
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/generate-project-skill/SKILL.md
size: 5238
sha: c8d271db787205c7bf5848e7d007d4f4855fe74f
upstream: https://github.com/skilld-dev/skilld/blob/main/skills/generate-project-skill/SKILL.md

```text
---
name: generate-project-skill
description: Generate or update an Agent Skill from the observed workflows, boundaries, and conventions of one software project.
license: MIT
compatibility: "Requires an agent with filesystem and shell access. Network access is needed for remote sources."
---

# Generate a project Skill

Create a compact, searchable Skill from the project itself.
This Skill is for maintainers who author a draft Skill they own.

## Inputs

Use the project directory or prepared project source.
Ask for the destination only when the request does not provide one.

## Inspect

1. Read project instructions and decision records first.
2. Read manifests, exported entry points, and build configuration.
3. Find the test, lint, typecheck, build, and release commands.
4. Trace the main public workflows through their real entry points.
5. Note generated directories and files an Agent must not edit.
6. Check recent changes when they explain current conventions.

## Project navigation

The Skill must let an Agent find any part of the project without a prior index.

1. Name the project from its manifest. Use the directory name when no manifest names it.
2. List the entry points the manifest declares, such as `main`, `module`, `types`, `exports`, and `bin`.
3. List the source and documentation directories an Agent reads most.
4. Use project-relative paths for every file pointer.
5. Never add a generated directory prefix to a project-relative path.
6. Give search commands the Agent can repeat, scoped to those directories.
7. Prefer `rg` for search. Name the directories to skip in the command.
8. Tell the Agent when project changes require a new Skill run.

Write the search commands so their results point at real project files.

Skip these paths while collecting project files:

- version-control data, such as `.git`
- dependency directories, such as `node_modules` and `vendor`
- generated output, such as `dist`, `build`, `target`, `.output`, `.nuxt`, and `.next`
- caches and reports, such as `coverage`
- credential files, such as `.env` and any private key

Skip any file larger than 512 KB.
Do not follow symbolic links while collecting project files.

## Output

Write one directory whose name matches the Skill name.
The directory must contain `SKILL.md`.
Use `references/` for architecture details and command guides.
Use `scripts/` only for reusable automation.

The `SKILL.md` frontmatter contains `name` and `description`. It may also contain `license`, `compatibility`, `metadata`, and `allowed-tools`.
If the project declares a license, copy its identifier into `license`. Never infer a license.
Include `compatibility` only for specific tool, runtime, network, or product requirements, at most 500 characters.
Omit it for general guidance. Do not repeat the package name, tested version, or implementation details.
`metadata` maps string keys to string values. `allowed-tools` is an experimental space-separated string of pre-approved tools.
Use lowercase letters, numbers, and single hyphens in the name.
Keep the name at 64 characters or fewer.

## Cross-Agent portability

Keep one source Skill for Claude Code, Codex, Gemini CLI, and other compatible Agents.
Their discovery paths differ. Keep installation instructions outside the generated Skill.
The [Agent Skills specification](https://agentskills.io/specification) defines the shared format.

- Describe capabilities, such as reading files or running a command, instead of provider-specific tool names.
- Ask for inputs explicitly. Do not require `$ARGUMENTS`, dynamic context injection, hooks, or a specific subagent API.
- State the project root as the working directory for project commands.
  Resolve bundled references and scripts from the Skill directory instead.
- Name required runtimes, binaries, network access, and credentials beside the step that needs them.
- If a required capability is unavailable, report the missing capability and stop that dependent step.
  Never invent evidence or silently skip a required check.

Check one matching task, one unrelated task, and one missing-input task.
Use a fresh session for each Agent the user asks to support when those Agents are available.
Record the Agent version, model, task, observed output, and any required permission.
Separate format validation, discovery, activation, and task completion in the report.
If an Agent is unavailable, report that path untested. Valid frontmatter alone does not prove portability.

## Quality checks

- Describe when the Skill applies.
- Do not explain the language, framework, or tools. The reader already knows them.
- Use project terms exactly.
- Point to source files instead of copying them.
- Run project commands only when they add useful evidence.
- Record the observed command and outcome.
- Include repeatable search commands for project source and documentation.
- Keep file pointers rooted at the real project directory.
- Separate rules from optional guidance.
- Remove stale, inferred, or duplicated instructions.
- Link each reference from `SKILL.md`.

For a direct run, show the generated files for user review.
Do not replace an existing Skill until the user approves it.
Do not claim that the Skill passed Harness checks.
```

## File: skills/generate-project-skill/assets/harness-request.md
size: 473
sha: c7b518b53f56543605b12a7fac94756c22928e22
upstream: https://github.com/skilld-dev/skilld/blob/main/skills/generate-project-skill/assets/harness-request.md

```text
# Harness request

Use the prepared project source at `{{SOURCE_PATH}}`.
If it exists, use the current Skill at `{{CURRENT_SKILL_PATH}}` as the update baseline.
Generate the project Skill at `{{OUTPUT_PATH}}`.
The Skill directory name must be `{{SKILL_NAME}}`.

Read this Skill fully before writing files.
Do not follow links or read outside the visible prepared source.
Write no files outside `{{OUTPUT_PATH}}`.
Finish only after checking every output rule in this Skill.
```

## File: README.md
upstream: https://github.com/skilld-dev/skilld/blob/main/README.md

````text
<h1 align="center">
<a href="https://skilld.dev"><picture>
<source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/skilld-dev/skilld/main/.github/logos/logo.svg">
<img alt="skilld" src="https://raw.githubusercontent.com/skilld-dev/skilld/main/.github/logos/logo-light.svg" width="260">
</picture></a>
</h1>

<p align="center">
Find, preview, run, and watch Agent Skills.<br>The open-source CLI behind <a href="https://skilld.dev">skilld.dev</a>.
</p>

<p align="center">
<a href="https://npmjs.com/package/skilld"><img alt="npm version" src="https://img.shields.io/npm/v/skilld?style=flat&labelColor=1c1917&color=e11d48"></a>
<a href="https://npm.chart.dev/skilld"><img alt="npm downloads" src="https://img.shields.io/npm/dm/skilld?style=flat&labelColor=1c1917&color=e11d48"></a>
<a href="https://github.com/skilld-dev/skilld/blob/main/LICENSE"><img alt="license" src="https://img.shields.io/github/license/skilld-dev/skilld?style=flat&labelColor=1c1917&color=e11d48"></a>
<a href="https://skilld.dev/gh/skilld-dev/skilld/skilld"><picture>
<source media="(prefers-color-scheme: dark)" srcset="https://skilld.dev/b/skilld-dev/skilld/skilld?theme=dark">
<source media="(prefers-color-scheme: light)" srcset="https://skilld.dev/b/skilld-dev/skilld/skilld?theme=light">
<img alt="Agent skill on skilld.dev" src="https://skilld.dev/b/skilld-dev/skilld/skilld?theme=light">
</picture></a>
</p>

<div align="center">
<table>
<tbody>
<tr>
<td align="center">
<sub>Made possible by my <a href="https://github.com/sponsors/harlan-zw">Sponsor Program 💖</a><br> Follow me <a href="https://twitter.com/harlan_zw">@harlan_zw</a> 🐦 • Join <a href="https://discord.gg/275MBUBvgP">Discord</a> for help</sub>
</td>
</tr>
</tbody>
</table>
</div>

## What is skilld?

[skilld.dev](https://skilld.dev) is a curated registry of Agent Skills.
Real maintainers write them in their own GitHub Repositories.
skilld.dev and the open-source `skilld` CLI cover four steps:

| Step | What you do | Where |
| --- | --- | --- |
| 🔥 **Find** | See the Skills devs talk about this week. | [Trending Skills](https://skilld.dev/skills/trending), `skilld trending`, `skilld search` |
| 🧑‍🎨 **Preview** | See what a Skill makes before you run it. | [Skill demos](https://skilld.dev/skills/demos) |
| 🏃‍♂️ **Run** | Run a Skill once, fork it, or install it. | `skilld run`, `skilld install` |
| 👀 **Watch** | Get a digest when the Skills you use change. | `skilld watch`, `skilld changes` |

A Skill is a directory with a `SKILL.md` file in the [Agent Skills](https://agentskills.io) format.
Most Skill directories rank by install count, or ship a generated doc dump.
skilld names the author, links the exact file, and records the commit it came from.
Read it before your Agent follows it.

The `skilld` CLI searches, runs, installs, updates, verifies, and removes Skills.
It contains no Skill generation logic and no Agent runtime.
Skill authoring lives in visible [skilld-maintained Skills](#author-a-skill) and the optional [Harness](#harness).

## Features

- 💬 **Ask your Agent to find and run Skills.** Install the `skilld` Skill once, then describe your task. Your Agent searches the registry and loads a Skill for you.
- 📖 **Use a Skill for one task.** Give your Agent a Skill URL and ask it to run the Skill. Loading the instructions writes no files.
- 🎯 **Keep Skills across sessions and Agents.** Ask your Agent to install a Skill when you want to keep it. skilld supports Claude Code, Codex, Cursor, Gemini CLI, Zed, and more.
- 🔏 **Know where a Skill came from.** Remote installs record the exact source commit. Ask your Agent to check for updates when you need them.
- 🛡️ **No telemetry.** The CLI sends no analytics. Account credentials go to your operating system keychain, never to a plain text file.

## Get started

Install the [`skilld` Skill](https://skilld.dev/gh/skilld-dev/skilld/skilld) so your Agent can find and run Skills:

```sh
npx skilld install skilld --global
```

This installs the Skill for your detected Agents across projects.
Start a new Agent session, then ask for what you need:

> Find me a good Skill for reviewing my Vue app.

> Run this Skill: https://skilld.dev/gh/antfu/skills/vue

Your Agent searches the registry, reads the Skill, and follows it for the current task.
To keep a Skill across sessions, ask your Agent to install it.

For setup through your Agent, paste this:

> Read https://skilld.dev/agent.md and follow it to set up skilld for me.

## Use the CLI

Every command below works through `npx` with no install.
To install the CLI, see [Install the CLI](#install-the-cli).

### Find a Skill

[Trending Skills](https://skilld.dev/skills/trending) ranks Skills by how many separate devs talked about each one this week.
Search the registry from a terminal:

```sh
npx skilld search vue
npx skilld trending
```

Every Skill page credits its author and links the source file on GitHub.
[Curators](https://skilld.dev/community) publish collections of the Skills they use.

### Preview it

Some Skills have demos.
Each demo is one recorded run: the prompt, and what the Agent built with the Skill.
Browse [every demo](https://skilld.dev/skills/demos), or open the Demo panel on a Skill page.

### Run it

Give your Agent a Skill URL. There is nothing to install:

> Use this Skill: https://skilld.dev/gh/antfu/skills/vue

Your Agent reads the page and follows it for that session.
Nothing is written to your project.
Add `.md` to any Skill URL for the raw `SKILL.md`.

From a terminal, `skilld run` does the same:

```sh
npx skilld run antfu/skills/vue
```

It prints `SKILL.md` to stdout and writes no file.
Pass the output to your Agent.

To change a Skill, ask your Agent to fork it:

> Fork this Skill: https://skilld.dev/gh/antfu/skills/vue

A fork creates an editable local Skill with its original author and license.

To keep a Skill in every session of one project, install it:

```sh
npx skilld install antfu/skills/vue
```

An install writes files. If an Agent runs the install, it asks you first.

| | `skilld run` | `skilld install` |
| --- | --- | --- |
| Use it for | The task in front of you | Every session in this project |
| Files written | None | `.skills`, the lockfile, and Agent targets |
| Cleanup | None | `skilld remove` |
| Updates | Loads the source each time | `skilld update` |
| Skill scripts | Never printed or executed | On disk for the Skill to use |

Start with `skilld run`. Install when you reach for the same Skill again.

### Watch for changes

Sign in, then watch the Repositories and collections you use:

```sh
npx skilld auth login
npx skilld watch antfu/skills
```

Each month, the digest email lists what changed. If nothing changed, skilld.dev sends nothing.
`skilld changes` prints the same changes from the last 30 days.
`skilld outdated` and `skilld update` keep your installed Skills current.

## Install the CLI

macOS and Linux:

```sh
curl -fsSL https://skilld.dev/install.sh | sh
```

Windows PowerShell:

```powershell
irm https://skilld.dev/install.ps1 | iex
```

npm, which needs Node.js:

```sh
npm install --global skilld
```

The script installs one native binary to `~/.skilld/bin`.
It adds that directory to PATH: in your shell profile on macOS and Linux, in your user PATH on Windows.
On macOS and Linux, set `SKILLD_NO_MODIFY_PATH=1` to leave your shell profile alone.

skilld checks for CLI upgrades in the background once a day.
If a newer release is cached, the next terminal invocation offers to upgrade.
Choose `Upgrade now`, `Not now`, or `Don't remind me for this version`.
The script install verifies the signed release manifest before replacing the executable.
Restart skilld to use the new version.
Recognized global npm, pnpm, Yarn, and Bun installs run their package manager after you confirm.
Local and transient installs show upgrade guidance instead.
After an upgrade, run your command again.
Set `SKILLD_NO_UPGRADE=1` to turn off upgrade checks.
See [SECURITY.md](./SECURITY.
````
