# Olakunlevpn Clean Export Skills

> Use when adding files to git, creating zip exports, or packaging a project for delivery. Ensures only actual project source files are included. Excludes agent configs, plan files, AI rules, markdown docs (except README.md), and non-project artifacts. Scans unknown files before including. Maintains a persistent .exclude file.

- Skill: `olakunlevpn/olakunlevpn-clean-export-skills` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add olakunlevpn/olakunlevpn-clean-export-skills`
- Raw SKILL.md: https://api.skillmd.com/api/skills/olakunlevpn/olakunlevpn-clean-export-skills/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: olakunlevpn (https://skillmd.com/u/olakunlevpn)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/olakunlevpn/olakunlevpn-clean-export-skills

---


# Clean Project Export

You are a strict file gatekeeper. This skill MUST be loaded automatically before ANY git operation or zip/export -- no matter how small. Do NOT wait for the user to ask.

**Auto-triggers:** `git add`, `git commit`, `git push`, zip, archive, export, package, "push this", "commit this", "add to git", "zip the project".

When triggered: scan files, enforce rules, block non-project files, strip AI attribution. Every time. No exceptions.

## Core Principle

**If a file does not run, compile, render, migrate, seed, test, configure the application, or serve as a required project asset -- it does NOT belong in the export.**

## ABSOLUTE RULE #0: NO AI ATTRIBUTION IN GIT

**NEVER add Claude, Copilot, Cursor, or ANY AI as a co-author, contributor, or collaborator in git commits, PR descriptions, or merge commits. The human developer is the sole author. Always. Zero exceptions. Check every commit message before pushing.**

---

## Rules (Non-Negotiable)

1. **ONLY project source files are added to git or zip.** No exceptions.
2. **NEVER add files without scanning first.** If uncertain, read the file before deciding.
3. **NEVER assume a file is safe to include.** Verify it is an actual project file.
4. **NEVER assume a new file is excluded.** Rescan when new files appear.
5. **ALWAYS maintain a `.exclude` file** at the project root listing all non-project files.
6. **ALWAYS preserve folder structure in zip exports.** Files keep their exact relative paths.
7. **README.md is the ONLY markdown file allowed.** All other `.md` files are excluded.
8. **When in doubt, read the file contents.** A file's name can be misleading -- contents tell the truth.
9. **Framework-shipped does NOT mean project-allowed.** If a starter template (`create-next-app`, `create-vue`, `create-react-app`, etc.) ships an AI/agent file (AGENTS.md, CLAUDE.md, .cursor/, .windsurf/, .codex/, etc.), it is STILL excluded. Convention authority does not override this skill. The dev is the sole author and the repo is the sole product.
10. **AI patterns live in `.exclude`, NOT `.gitignore`.** `.gitignore` contains only standard dev junk (node_modules, build artifacts, .env, OS files) plus the single line `.exclude`. AI/agent/plan/skill/scratch patterns belong in `.exclude` only. Do not pollute `.gitignore` with AI categories.
11. **Run a template scan immediately after `create-*-app` or any scaffolder.** Before the first commit, list every file the template created and verify each one against the inclusion list. Untracked AI files from a template are the most common leak path.
12. **Comments in `.gitignore` should be minimal.** No prose explanations. Standard dev tools recognise the patterns. The only allowed annotation is the leading `.exclude` line, uncommented.
13. **Verify clean tree before AND after every push.** Run `git ls-tree -r HEAD --name-only | grep -iE "AGENTS|CLAUDE|\.claude|\.cursor|\.exclude|\.env"`. Output must be empty. Run again after push to confirm what shipped.
14. **If an AI/agent file ships by accident, do not patch forward.** Wipe local `.git`, re-init, single clean root commit, force push. Three-commit history with "removed AGENTS.md" cleanup is worse than one clean commit.

---

## What Gets INCLUDED (Project Files)

These are actual project files that ship with the application:

```
SOURCE CODE:
- .php, .py, .js, .ts, .jsx, .tsx, .vue, .svelte, .rb, .go, .rs, .java, .kt, .swift, .c, .cpp, .h
- .blade.php, .edge, .ejs, .pug, .twig, .hbs

CONFIGURATION (Application):
- .env.example (never .env itself)
- composer.json, composer.lock
- package.json, package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb
- tsconfig.json, jsconfig.json
- vite.config.*, webpack.config.*, next.config.*, nuxt.config.*
- tailwind.config.*, postcss.config.*
- phpunit.xml, pest.php, vitest.config.*, jest.config.*
- .eslintrc.*, .prettierrc.*, .stylelintrc.*
- .editorconfig
- docker-compose.yml, Dockerfile, .dockerignore
- nginx.conf, apache.conf, Procfile
- Makefile, Rakefile, Gemfile, Gemfile.lock
- .github/workflows/*.yml (CI/CD pipelines)
- phpstan.neon, psalm.xml, pint.json

ASSETS:
- .css, .scss, .sass, .less, .styl, .pcss
- .svg, .png, .jpg, .jpeg, .gif, .webp, .ico, .avif
- .woff, .woff2, .ttf, .eot, .otf
- .mp4, .webm, .mp3, .wav, .ogg
- .pdf (if project asset, not documentation)

DATA & DATABASE:
- migrations/, seeders/, factories/
- .sql files (schema, seeds)
- .json, .xml, .yaml, .yml (data/config files within the project)
- .csv (if fixture/seed data)

LANGUAGE & LOCALIZATION:
- lang/, locales/, i18n/, translations/
- .po, .pot, .mo files

VIEWS & TEMPLATES:
- resources/views/, templates/, layouts/
- public/ directory contents

TESTS:
- tests/ directory
- .test.*, .spec.*, *Test.php, *_test.*

PROJECT ROOT FILES:
- README.md (the ONLY allowed .md file)
- LICENSE, LICENSE.md, LICENSE.txt
- .gitignore
- .gitattributes
- artisan (Laravel)
- server.php (Laravel)
- bootstrap/, public/index.php
```

---

## What Gets EXCLUDED (Non-Project Files)

These are NEVER added to git or zip:

```
AGENT & AI FILES:
- .claude/ directory (all contents)
- .cursor/ directory
- .agents/ directory
- .continue/ directory
- .codebuddy/ directory
- .windsurf/ directory
- .augment/ directory
- .codex/ directory
- CLAUDE.md, .claude-plugin/
- .cursorrules, .cursorignore
- .copilot/
- Any file containing agent instructions or AI system prompts

PLAN & DOCUMENTATION FILES (except README.md):
- PLAN.md, PLANS.md, plan.md, plan.txt
- ARCHITECTURE.md, DESIGN.md, SPEC.md, SPECIFICATION.md
- NOTES.md, NOTES.txt, notes/
- TODO.md, TODO.txt, TASKS.md
- CHANGELOG.md (unless explicitly part of a published package)
- CONTRIBUTING.md (unless explicitly part of a published package)
- ROADMAP.md, DECISIONS.md, ADR/
- docs/ directory (unless user confirms it ships with the project)
- *.md (ALL markdown except README.md -- this is strict)

SKILLS & RULES FILES:
- SKILL.md, skills/
- rules.json, rules.yaml, rules/
- .rules, .cursorrules
- .eslint-rules (custom, not .eslintrc)
- REFERENCE.md (skill reference files)
- Any file with "skill", "rule", or "agent" in the path

ENVIRONMENT & SECRETS:
- .env (NEVER -- only .env.example is allowed)
- .env.local, .env.production, .env.staging, .env.testing
- *.pem, *.key, *.cert, *.p12, *.jks
- credentials.json, service-account.json
- Any file containing API keys, tokens, or secrets

BUILD ARTIFACTS & DEPENDENCIES:
- node_modules/, vendor/ (unless deploying without install)
- .next/, .nuxt/, .output/
- dist/, build/, out/ (unless deploying static build)
- storage/framework/cache/, storage/framework/sessions/, storage/framework/views/
- bootstrap/cache/*.php (Laravel compiled)
- .phpunit.result.cache, .php-cs-fixer.cache
- *.log, storage/logs/

OS & IDE FILES:
- .DS_Store, Thumbs.db, desktop.ini
- .idea/, .vscode/ (unless shared team settings)
- *.swp, *.swo, *~, *.bak, *.tmp
- .project, .classpath, .settings/

MEMORY & SESSION FILES:
- MEMORY.md, memory/
- .local.md files
- *.session, *.pid

TEMPORARY & GENERATED:
- tmp/, temp/, .tmp/
- coverage/, .nyc_output/
- .parcel-cache/, .turbo/, .vercel/, .netlify/
```

---

## Two-File System: `.gitignore` vs `.exclude`

Project uses BOTH files. Different purpose. No overlap.

### `.gitignore` (standard junk — commit to git)

Holds universally-known ignore patterns every dev expects. Shared with team. Pushed to GitHub.

NEVER list AI/agent/plan/skill patterns here. Those go in `.exclude` only.
The only project-specific line allowed is the `.exclude` reference itself,
on its own with no comment block.

```
.exclude

# dependencies
.env
.env.local
.env.*.local
node_modules/
vendor/

# framework build
.next/
.nuxt/
dist/
build/
out/

# laravel storage
storage/logs/
storage/framework/cache/
storage/framework/sessions/
storage/framework/views/
bootstrap/cache/*.php

# logs
*.log

# os
.DS_Store
Thumbs.db

# editors (only if not shared)
.idea/
.vscode/

# coverage
coverage/
.phpunit.result.cache
.php-cs-fixer.cache

# secrets
*.pem
*.key
```

DO NOT add: `AGENTS.md`, `CLAUDE.md`, `.claude/`, `.cursor/`, `.windsurf/`,
`.codex/`, `.cursorrules`, `PLAN.md`, `SKILL.md`, or any AI/plan pattern to
`.gitignore`. Those belong in `.exclude` and the workflow keeps them off the
staging area through explicit `git add <path>` calls.

### `.exclude` (custom/AI/plan junk — NEVER commit, NEVER zip)

Holds project-specific non-project files: agent configs, plan files, skill rules, AI instructions, personal notes. Local-only. Never pushed to GitHub. Never included in zip exports.

```
# .exclude - Non-project files identified by clean export scan
# LOCAL ONLY. Never commit. Never zip. Never push.
# Auto-generated. Rescan to discover new files.
# Last scanned: [date]

# Agent & AI
.claude/
.cursor/
.agents/
.continue/
.windsurf/
.codex/
CLAUDE.md
CLAUDE.original.md
.cursorrules

# Plans & Docs (except README.md)
PLAN.md
PLANS.md
ARCHITECTURE.md
DESIGN.md
SPEC.md
NOTES.md
TODO.md
CHANGELOG.md
ROADMAP.md
docs/

# Skills & Rules
SKILL.md
skills/
rules.json
rules.yaml
.rules
REFERENCE.md

# Memory & Session
MEMORY.md
memory/
*.local.md

# Temporary
tmp/
temp/
.tmp/
scratch.*
```

### Split Rule

- If ignore pattern is **standard dev knowledge** (every dev knows to skip) → `.gitignore`
- If ignore pattern is **AI/plan/skill/custom** (project-specific, not universal) → `.exclude`
- No duplication. A file belongs in one place only.

### Rules for `.exclude`

1. **Create on first scan.** After scanning the project for the first time, write `.exclude`.
2. **Update on rescan.** When new files appear, add them to `.exclude` after verification.
3. **Never assume new files are excluded.** New file must be scanned and classified before adding.
4. **`.exclude` is LOCAL ONLY.** Never commit. Never push. Never include in zip.
5. **Auto-add `.exclude` to `.gitignore`.** First line of `.gitignore` must contain `.exclude`.
6. **Zip exports must exclude `.exclude` itself.** Verify before zipping.
7. **Comment sections for clarity.** Group exclusions by category.

### Enforcement checklist

Before ANY git add / commit / push / zip:
- [ ] `.gitignore` exists and contains `.exclude` entry
- [ ] `.exclude` is NOT in staged files (`git diff --cached --name-only | grep -v '^\.exclude$'`)
- [ ] `.exclude` is NOT in zip file list
- [ ] Files in `.exclude` are NOT staged or zipped

If `.exclude` appears staged → `git reset HEAD .exclude` immediately.
If `.exclude` appears in zip → rebuild zip without it.

---

## Scanning Process

### Full Scan (First time or when requested)

```
STEP 1: List ALL files in the project (recursive, excluding .git/)
STEP 2: Classify each file:
  - KNOWN PROJECT FILE -> include (matches the inclusion list above)
  - KNOWN NON-PROJECT FILE -> exclude (matches the exclusion list above)
  - UNKNOWN FILE -> inspect

STEP 3: For UNKNOWN files:
  a. Read the file contents (first 50-100 lines)
  b. Determine purpose:
     - Contains code that runs/compiles? -> PROJECT FILE
     - Contains agent instructions or AI prompts? -> EXCLUDE
     - Contains a plan, spec, or documentation? -> EXCLUDE (unless README.md)
     - Contains project configuration? -> PROJECT FILE
     - Contains data the app uses at runtime? -> PROJECT FILE
     - Still unclear? -> ASK THE USER before deciding
  c. Add classification to .exclude if excluded

STEP 4: Report findings:
  "Scan complete:
   - [X] project files identified
   - [Y] non-project files excluded
   - [Z] files need your review: [list them]"

STEP 5: Write/update .exclude file
```

### Incremental Scan (New files detected)

```
STEP 1: List all files NOT in .exclude and NOT already tracked
STEP 2: Classify new files using the same process
STEP 3: Update .exclude with new exclusions
STEP 4: Report what was found
```

### Template Scan (after a scaffolder runs)

Run this immediately after `create-next-app`, `create-vue`, `create-react-app`,
`degit`, `nest new`, `rails new`, `django-admin startproject`, or any other
project bootstrapper. Templates ship AI/agent files as a "feature." Catch
them before the first commit lands.

```
STEP 1: List EVERY file the template created at the project root:
   ls -la

STEP 2: Flag for inspection any of:
   AGENTS.md, CLAUDE.md, COPILOT.md, CURSOR.md
   .claude/, .cursor/, .windsurf/, .codex/, .continue/, .augment/
   .cursorrules, .copilotignore
   any *.md other than README.md
   any prompts/ instructions/ rules/ skills/ directory

STEP 3: For each flagged file: EXCLUDE by default. Convention authority
   ("but Next.js/Shopify/etc ships this") is NOT a reason to include.

STEP 4: Update .exclude with everything flagged.

STEP 5: If a flagged file was already committed by the scaffolder's
   initial commit:
   - git rm --cached <file>
   - Stage the removal
   - If this is the only commit: wipe .git and re-init clean
   - If there are other commits: amend or follow Rule #14

STEP 6: Verify with the post-stage check before any commit:
   git diff --cached --name-only | grep -iE "AGENTS|CLAUDE|COPILOT|CURSOR|\.claude|\.cursor|\.windsurf|\.codex|\.exclude|\.env"
   Output MUST be empty.
```

### Signs a File Needs Inspection

Read the file if ANY of these are true:

```
- File name is generic (notes.txt, plan.txt, todo.txt, scratch.*)
- File name contains "agent", "claude", "cursor", "copilot", "ai", "llm"
- File name contains "plan", "spec", "design", "architecture", "decision"
- File name contains "rule", "skill", "prompt", "instruction"
- File has an unexpected extension for its location
- File is in the project root and not a recognized config file
- File is markdown but not README.md
- File is a JSON/YAML that doesn't look like app config
- File has no extension
- File seems unusually large or small for its type
```

---

## Git Operations

### Adding files to git

```
BEFORE running git add:
1. Check .gitignore exists and contains `.exclude` entry. If missing, add it.
2. Check .exclude exists. If not, run a full scan first.
3. Check for new untracked files not in .exclude or .gitignore -- scan them.
4. NEVER use: git add . or git add -A or git add --all
5. ALWAYS add specific files or use patterns:
   git add app/ config/ database/ resources/ routes/ tests/ public/
   git add composer.json composer.lock package.json
   git add .gitignore .editorconfig
   git add README.md LICENSE
6. NEVER add .exclude -- it is LOCAL ONLY.
7. Double-check staged files: git status
8. If ANY excluded file appears in staged, unstage it immediately.
9. If .exclude appears staged: git reset HEAD .exclude
10. Run the AI-leak grep on staged files:
    git diff --cached --name-only | grep -iE "AGENTS|CLAUDE|COPILOT|CURSOR|\.claude|\.cursor|\.windsurf|\.codex|\.exclude|\.env"
    If output is non-empty, unstage every match and rescan.
```

### Pre-push verification (run every push, no exceptions)

```
1. Verify HEAD tree contains no AI/agent leak:
   git ls-tree -r HEAD --name-only | grep -iE "AGENTS|CLAUDE|COPILOT|CURSOR|\.claude|\.cursor|\.windsurf|\.codex|\.exclude|\.env"
   Output MUST be empty. If not, abort and clean.

2. Verify the commit message has no AI attribution:
   git log -1 --format=%B | grep -iE "claude|anthropic|copilot|cursor|cline|openai|gpt|co-authored"
   Output MUST be empty.

3. Verify author identity is the human dev:
   git log -1 --format="%an <%ae>"
   Must NOT be Claude, Anthropic, Cursor, Copilot, or any AI vendor.

4. After push, verify the same on the remote tip:
   git ls-remote origin
   Then re-run step 1 against origin/main.

If ANY check fails after push: abort, wipe local .git, re-init, single
clean root commit, force push. Do not patch forward (Rule #14).
```

### Creating commits

```
BEFORE committing:
1. Run: git status
2. Verify EVERY staged file is a project file
3. Check for accidentally staged:
   - .env (CRITICAL -- never commit)
   - .exclude (CRITICAL -- never commit, local only)
   - .claude/, .cursor/, .agents/
   - Plan files, skill files, rule files
   - node_modules/, vendor/ paths
   - .DS_Store, Thumbs.db
4. If anything suspicious is staged: git reset HEAD [file]
5. Verify .gitignore contains `.exclude` line. Add if missing.
```

### Commit Authorship (ABSOLUTE ZERO TOLERANCE)

**THIS IS THE MOST STRICTLY ENFORCED RULE IN THIS ENTIRE SKILL.**

```
ABSOLUTELY NEVER -- UNDER ANY CIRCUMSTANCES -- ADD AI AS A
CONTRIBUTOR, CO-AUTHOR, OR COLLABORATOR TO ANY GIT COMMIT.

BANNED in commit messages:
- "Co-Authored-By: Claude" -- BANNED
- "Co-Authored-By: Claude Opus" -- BANNED
- "Co-Authored-By: Claude Sonnet" -- BANNED
- "Co-Authored-By: Claude Haiku" -- BANNED
- "Co-Authored-By: Claude Code" -- BANNED
- "Co-Authored-By: *anthropic*" -- BANNED
- "Co-Authored-By: *openai*" -- BANNED
- "Co-Authored-By: *Copilot*" -- BANNED
- "Co-Authored-By: *Cursor*" -- BANNED
- "Co-Authored-By: *Cline*" -- BANNED
- "Co-Authored-By: *AI*" -- BANNED
- ANY variation of "noreply@anthropic.com" -- BANNED
- ANY AI model name (opus, sonnet, haiku, gpt, gemini) -- BANNED
- "Generated by AI/Claude/Copilot" -- BANNED
- "Assisted by AI/Claude/Copilot" -- BANNED
- "Written by AI/Claude/Copilot" -- BANNED
- "Created with AI/Claude/Copilot" -- BANNED

BANNED in commit trailers:
- Co-Authored-By with ANY AI name or email
- Signed-off-by with ANY AI name or email
- Reviewed-by with ANY AI name or email

BANNED in PR descriptions:
- ANY mention of AI tools generating the code
- ANY AI attribution or credit line
- ANY "built with Claude/Copilot/Cursor" badges or text

BANNED in merge commits:
- Same rules as above. No exceptions.

THE DEVELOPER IS THE SOLE AUTHOR. ALWAYS. NO EXCEPTIONS.
NO DISCLAIMERS. NO FOOTNOTES. NO SMALL PRINT.

If you catch yourself about to add Co-Authored-By with any AI
name -- STOP. Remove it. The commit message contains ONLY what
changed and why. Nothing about who or what generated it.
```

**BEFORE EVERY COMMIT, VERIFY:**
```
1. Read the full commit message
2. Check for ANY AI name, email, or attribution
3. Check for Co-Authored-By trailer
4. If found: REMOVE IT before committing
5. This check is MANDATORY. Never skip it.
```

---

## Zip Export Operations

### Creating a zip

```
STEP 1: Run scan (full or incremental)
STEP 2: Build file list (project files only).
        EXCLUDE ALWAYS:
        - .exclude (LOCAL ONLY, never zip)
        - Everything listed in .exclude
        - Everything listed in .gitignore
STEP 3: Create zip with EXACT folder structure preserved:
   - Every file keeps its relative path from project root
   - Folder hierarchy is identical inside the zip
   - No flat dump of files -- structure matters
STEP 4: Verify .exclude not in zip: unzip -l archive.zip | grep '\.exclude'
   - If found: rebuild zip without it
STEP 5: Place zip in folder user specifies
STEP 6: Report:
   "Created [name].zip in [path]
    - [X] files included
    - [Y] files excluded (.exclude, .gitignore patterns, AI/plan junk)
    - Total size: [size]"
```

### Zip structure example

```
project-name.zip
├── app/
│   ├── Http/
│   │   └── Controllers/
│   │       └── OrderController.php
│   └── Models/
│       └── Order.php
├── config/
│   └── app.php
├── database/
│   └── migrations/
│       └── 2024_01_01_create_orders_table.php
├── resources/
│   └── js/
│       └── Pages/
│           └── Orders/
│               └── Index.tsx
├── routes/
│   └── web.php
├── tests/
│   └── Feature/
│       └── OrderTest.php
├── composer.json
├── package.json
├── README.md
└── .gitignore
```

Every file in its exact original path. No exceptions.

---

## Edge Cases

### docs/ directory
Ask: "Does the docs/ directory ship with your application (e.g., API docs served by the app)? Or is it development documentation?"
- Ships with app -> include
- Development docs -> exclude

### .json/.yaml files in project root
Read the file. If it contains:
- App configuration -> include
- Agent/skill/rule definitions -> exclude
- Plan or spec data -> exclude

### Compiled/built assets in public/
- public/build/, public/dist/ -> include only if this IS the deployment (no build step on server)
- Ask if uncertain

### Monorepo packages/
Each sub-package follows the same rules independently.

---

## How to Use

**Scan a project for the first time:**
```
Scan this project and identify all non-project files. Create the .exclude file.
```

**Add project files to git:**
```
Add all project files to git. Skip everything that isn't source code or config.
```

**Create a zip export:**
```
Zip the project files and put the zip in /Users/me/Desktop/
```

**Rescan after adding new files:**
```
I added some new files. Rescan and update .exclude.
```

**Check what would be included:**
```
Show me what files would be included in a git add or zip, and what would be excluded.
```

**Verify current git staging:**
```
Check my git staging area for any files that shouldn't be committed.
```