Project Guidelines Example
Copy a production-shaped project SKILL.md template so your agent follows one app’s architecture, patterns, tests, and deploy steps.
Overview
Project-guidelines-example is an agent skill most often used in Build (also Ship) that provides a project-specific SKILL.md template—architecture, structure, patterns, testing, and deployment—modeled on a real production
Install
npx skills add https://github.com/affaan-m/everything-claude-code --skill project-guidelines-exampleWhat is this skill?
- Example based on Zenith—a real AI customer-discovery production app
- Sections for architecture, file structure, code patterns, testing, and deployment
- Reference stack: Next.js 15 App Router, FastAPI, Supabase, Claude API, Cloud Run
- Shows frontend/backend service diagram and boundary expectations
- Explicit “When to Use” for project-bound work only
- Example models a multi-service stack: Next.js 15 frontend, FastAPI backend, Supabase, Claude API, Cloud Run
Adoption & trust: 1.7k installs on skills.sh; 210k GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your agent keeps inventing folder layouts, test commands, and deploy steps because nothing authoritative describes your actual production app.
Who is it for?
Solo builders authoring a dedicated project skill after the stack is chosen and a repo structure exists.
Skip if: Greenfield repos with no settled architecture yet—brainstorm and plan first, then codify guidelines.
When should I use this skill?
Reference when working on the specific project the skill describes; SKILL.md states use when you need architecture, file structure, patterns, testing requirements, and deployment workflow in one place.
What do I get? / Deliverables
You get a fill-in template and reference sections so your own project skill documents stack, services, patterns, and workflows agents must follow on every change.
- Customized project guidelines skill for your repository
- Documented architecture diagram, patterns, test matrix, and deploy checklist
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Build is the primary shelf because the template encodes how to implement and maintain a specific codebase, not how to discover the idea or run post-launch growth. Docs fits best: project skills are living convention documents—architecture, file layout, patterns—that agents reference while coding.
Where it fits
Draft your project SKILL.md sections by copying the architecture and file-structure headings from the Zenith example.
Point the agent at App Router and TypeScript patterns before a large UI refactor.
Align FastAPI and Pydantic conventions when adding new API routes.
Verify deploy steps against the documented Google Cloud Run workflow before release.
How it compares
Use as a project SKILL.md blueprint, not as a global harness like Everything Claude Code or a single API integration skill.
Common Questions / FAQ
Who is project-guidelines-example for?
Indie developers and small teams who maintain one main codebase and want agents to read fixed architecture, testing, and deployment rules from a project skill.
When should I use project-guidelines-example?
Use it in Build when editing features across Next.js and FastAPI layers, in Build/docs when writing your SKILL.md, and in Ship/launch when deployment steps must match the documented Cloud Run workflow.
Is project-guidelines-example safe to install?
It is an in-repo documentation template with no runtime hooks; still review the Security Audits panel on this page and redact secrets before committing your customized project skill.
SKILL.md
READMESKILL.md - Project Guidelines Example
# Project Guidelines Skill (Example) This is an example of a project-specific skill. Use this as a template for your own projects. Based on a real production application: [Zenith](https://zenith.chat) - AI-powered customer discovery platform. ## When to Use Reference this skill when working on the specific project it's designed for. Project skills contain: - Architecture overview - File structure - Code patterns - Testing requirements - Deployment workflow --- ## Architecture Overview **Tech Stack:** - **Frontend**: Next.js 15 (App Router), TypeScript, React - **Backend**: FastAPI (Python), Pydantic models - **Database**: Supabase (PostgreSQL) - **AI**: Claude API with tool calling and structured output - **Deployment**: Google Cloud Run - **Testing**: Playwright (E2E), pytest (backend), React Testing Library **Services:** ``` ┌─────────────────────────────────────────────────────────────┐ │ Frontend │ │ Next.js 15 + TypeScript + TailwindCSS │ │ Deployed: Vercel / Cloud Run │ └─────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ Backend │ │ FastAPI + Python 3.11 + Pydantic │ │ Deployed: Cloud Run │ └─────────────────────────────────────────────────────────────┘ │ ┌───────────────┼───────────────┐ ▼ ▼ ▼ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ Supabase │ │ Claude │ │ Redis │ │ Database │ │ API │ │ Cache │ └──────────┘ └──────────┘ └──────────┘ ``` --- ## File Structure ``` project/ ├── frontend/ │ └── src/ │ ├── app/ # Next.js app router pages │ │ ├── api/ # API routes │ │ ├── (auth)/ # Auth-protected routes │ │ └── workspace/ # Main app workspace │ ├── components/ # React components │ │ ├── ui/ # Base UI components │ │ ├── forms/ # Form components │ │ └── layouts/ # Layout components │ ├── hooks/ # Custom React hooks │ ├── lib/ # Utilities │ ├── types/ # TypeScript definitions │ └── config/ # Configuration │ ├── backend/ │ ├── routers/ # FastAPI route handlers │ ├── models.py # Pydantic models │ ├── main.py # FastAPI app entry │ ├── auth_system.py # Authentication │ ├── database.py # Database operations │ ├── services/ # Business logic │ └── tests/ # pytest tests │ ├── deploy/ # Deployment configs ├── docs/ # Documentation └── scripts/ # Utility scripts ``` --- ## Code Patterns ### API Response Format (FastAPI) ```python from pydantic import BaseModel from typing import Generic, TypeVar, Optional T = TypeVar('T') class ApiResponse(BaseModel, Generic[T]): success: bool data: Optional[T] = None error: Optional[str] = None @classmethod def ok(cls, data: T) -> "ApiResponse[T]": return cls(success=True, data=data) @classmethod def fail(cls, error: str) -> "ApiResponse[T]": return cls(success=False, error=error) ``` ### Frontend API Calls (TypeScript) ```typescript interface ApiResponse<T> { success: boolean data?: T error?: string } async function fetchApi<T>( endpoint: string, options?: RequestInit ): Promise<ApiResponse<T>> { try { const response = await fetch(`/api${endp