Agent skill

learn-project

Scan project code to detect patterns, dependencies, and conventions. Propose domain rules based on what the code actually does.

View SKILL.md on GitHub Repository
Stars 163
Forks 31

Install this agent skill to your Project

npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/other/other/learn-project

SKILL.md

Learn Project

Scan the current project's source code to detect patterns, classify tooling, and propose domain rules. Unlike /forge domain extract (which reads dotforge's internal memory), this skill reads the CODE directly.

Step 1: Detect dependency files

Read whichever exist (skip missing):

  • package.json — extract dependencies + devDependencies keys
  • pyproject.toml — extract [project.dependencies] and [tool.*] sections
  • requirements.txt — read all lines
  • go.mod — extract require block
  • Podfile — read all lines
  • Gemfile — read all lines
  • pom.xml / build.gradle / build.gradle.kts — extract dependency declarations

Collect a flat list of dependency names.

Step 2: Scan imports

Find the top 20 most-imported libraries across the codebase:

bash
# Python
grep -rh "^import \|^from " --include="*.py" . 2>/dev/null | sed 's/import //;s/from //;s/ .*//' | sort | uniq -c | sort -rn | head -20

# TypeScript/JavaScript
grep -rh "from ['\"]" --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" . 2>/dev/null | sed "s/.*from ['\"]//;s/['\"].*//" | grep -v '^\.' | sort | uniq -c | sort -rn | head -20

# Go
grep -rh "\"" --include="*.go" . 2>/dev/null | grep -E '^\s+"' | sed 's/.*"//;s/".*//' | sort | uniq -c | sort -rn | head -20

# Swift
grep -rh "^import " --include="*.swift" . 2>/dev/null | sed 's/import //' | sort | uniq -c | sort -rn | head -20

Step 3: Scan project structure

bash
# Directory structure (2 levels deep, ignore hidden/vendor)
find . -maxdepth 2 -type d ! -path '*/\.*' ! -path '*/node_modules*' ! -path '*/.venv*' ! -path '*/vendor*' ! -path '*/__pycache__*' | sort

# Config files present
ls -1 .eslintrc* .prettierrc* ruff.toml pyproject.toml tsconfig.json biome.json jest.config* vitest.config* vite.config* webpack.config* Makefile Dockerfile docker-compose* .env.example 2>/dev/null

Step 4: Classify patterns

From Steps 1-3, classify into categories. Only report categories with HIGH CONFIDENCE (direct evidence in code):

ORM/Database:

  • SQLAlchemy (import sqlalchemy, from sqlalchemy)
  • Prisma (@prisma/client)
  • TypeORM (import { Entity } from "typeorm")
  • GORM (gorm.io/gorm)
  • Supabase (@supabase/supabase-js, supabase-py)
  • Raw SQL (psycopg2, pg, mysql2)

Auth:

  • JWT (python-jose, jsonwebtoken, @auth/core)
  • OAuth (authlib, passport, next-auth)
  • Session-based (express-session, flask-session)
  • Supabase Auth (@supabase/auth-helpers)

Test framework:

  • pytest, vitest, jest, mocha, go test, XCTest
  • Detect test directory: tests/, tests/, spec/, test/

Build system:

  • Vite, webpack, esbuild, rollup, turbopack
  • setuptools, poetry, hatch
  • Make (Makefile targets)

API framework:

  • FastAPI, Express, Koa, Fastify, Gin, Echo, Fiber
  • REST vs GraphQL (detect graphql imports/schema files)

State management:

  • Zustand, Redux, MobX, Recoil, Jotai
  • SwiftUI @Observable, @State, @Binding

Deployment:

  • Docker (Dockerfile, docker-compose)
  • Serverless (serverless.yml, sam template)
  • Cloud Run (app.yaml, cloudbuild.yaml)
  • Vercel (vercel.json)

Naming conventions:

bash
# Function naming: snake_case vs camelCase
grep -rh "def [a-z]" --include="*.py" . 2>/dev/null | head -5  # snake_case
grep -rh "function [a-z]" --include="*.ts" --include="*.js" . 2>/dev/null | head -5  # camelCase

Step 5: Present proposals

Show detected patterns grouped by category. For each, propose a domain rule:

═══ /forge learn — [project-name] ═══

Detected patterns (high confidence only):

1. ORM: SQLAlchemy 2.x (async sessions detected in 8 files)
   Proposed rule: .claude/rules/domain/orm-patterns.md
   Content: async session lifecycle, model conventions, migration patterns
   → Create? [approve/skip/edit]

2. Auth: Supabase Auth (auth-helpers in 4 files)
   Proposed rule: .claude/rules/domain/auth-flow.md
   Content: session management, RLS policies, token refresh
   → Create? [approve/skip/edit]

3. Testing: vitest (vitest.config.ts found, 23 test files)
   Proposed rule: .claude/rules/domain/testing.md
   Content: test patterns, mock conventions, coverage targets
   → Create? [approve/skip/edit]

4. Naming: snake_case (Python), camelCase (TypeScript)
   Proposed rule: .claude/rules/domain/naming.md
   Content: per-language conventions detected
   → Create? [approve/skip/edit]

Wait for user approval on each before creating files.

Step 6: Generate approved rules

For each approved proposal, create a rule file in .claude/rules/domain/:

markdown
---
globs: "<relevant file patterns>"
description: "<what this rule covers>"
domain: "<project-name>"
last_verified: "<today YYYY-MM-DD>"
source: "/forge learn"
---

# <Title>

<Factual observations from the scan — imperative mood, concise>

Rules must be:

  • Under 40 lines
  • Factual (observed in code, not assumed)
  • Actionable (tell Claude what to do, not what exists)
  • English only

Step 7: Report summary

═══ Learn complete ═══
Scanned: <N> dependency files, <N> imports, <N> config files
Detected: <N> patterns across <N> categories
Created: <N> domain rules in .claude/rules/domain/
Skipped: <N> proposals

Tip: run /forge domain extract to capture session-learned knowledge too.

What this skill does NOT do

  • Does not read dotforge memory, errors, or agent memory (use /forge domain extract for that)
  • Does not modify existing rules (only creates new ones in domain/)
  • Does not run any code or install dependencies
  • Does not guess — only reports patterns with direct evidence in the codebase

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

majiayu000/claude-skill-registry

agent-ops-spec

Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-state

Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-spec

Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-testing

Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-testing

Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-state

Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.

163 31
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results