Gpt Export

GPT Export — Custom GPT Knowledge Package

Generate a complete Custom GPT knowledge package from the current workspace project. Produces 21 markdown files: 20 documentation files covering every dimension needed for high-level strategic collaboration, plus 1 optimized custom instructions file (≤7,500 characters).

Purpose

This skill creates everything needed to build a Custom GPT strategic consultant for the current project. The GPT is NOT a coding partner — it's a high-level collaborator for strategy, design, UI architecture, information architecture, user experience, content strategy, and product decisions. It knows the frameworks and technologies in use but advises at the design and decision layer, not the implementation layer.

Arguments

$ARGUMENTS — Optional output directory path. Defaults to _docs/custom-gpt/.

If $ARGUMENTS is provided, use it as the output directory. Otherwise use _docs/custom-gpt/.

Process

Phase 1 — Deep Project Discovery

Before generating any files, thoroughly explore the workspace to understand:

1. Project identity — Read README, CLAUDE.md, package.json, any manifest files
2. Architecture — Directory structure, framework, routing, data flow
3. Design system — CSS variables, Tailwind config, color tokens, typography, component library
4. Pages & routes — All user-facing pages, their purpose, hierarchy
5. Content model — Content types, taxonomies, relationships
6. User flows — Authentication, onboarding, conversion, engagement loops
7. Features — Feature flags, capabilities, integrations
8. Navigation & IA — Header, footer, sidebar, breadcrumbs, menus
9. Brand & voice — Tone, messaging, copy patterns
10. Tech stack — All dependencies and their roles
11. Tenant/config system — What's configurable vs hardcoded
12. AI/agent capabilities — Any AI features, chatbots, assistants
13. Conversion architecture — Pricing, CTAs, subscription tiers, funnels
14. Animation & motion — Motion design approach, libraries, patterns
15. SEO & performance — Metadata, sitemap, Core Web Vitals approach
16. Third-party integrations — APIs, services, webhooks
17. Conventions & constraints — Team rules, patterns, anti-patterns
18. Responsive strategy — Breakpoints, mobile-first patterns
19. Accessibility — A11y approach, ARIA patterns, contrast
20. Current state — What's shipped, what's in progress, known gaps

Use the Agent tool with Explore subagents to parallelize discovery. Read key files directly when you know what you're looking for.

Phase 2 — Generate 20 Documentation Files

Create each file with clear, structured content optimized for GPT retrieval. Each file should:

• Start with a # Title and one-line summary
• Use consistent heading levels (##, ###)
• Front-load the most important information
• Use tables for structured data
• Use bullet lists for enumerations
• Avoid code blocks longer than 10 lines (this is for strategy, not implementation)
• Include cross-references to other files where relevant (e.g., "See also: 04-DESIGN-SYSTEM.md")
• Be 300–800 words (sweet spot for GPT retrieval chunking)

File Manifest

Phase 3 — Generate Custom Instructions (File 20)

The custom instructions file (20-CUSTOM-INSTRUCTIONS.md) must be ≤7,500 characters and should:

1. Open with identity & role — "You are [Project Name] Strategic Consultant, an expert advisor for..."
2. Define scope — Strategy, design, UX, IA, content strategy, product decisions. NOT a code writer.
3. Reference knowledge files explicitly — "Consult [filename] when answering questions about X"
4. Set behavioral rules:
   • Always ground answers in the uploaded project knowledge
   • Cite which knowledge file informed the answer
   • Ask clarifying questions before making recommendations
   • Consider trade-offs and present options, not just one answer
   • Respect existing conventions and constraints
   • Think in terms of user impact, not technical implementation
5. Define response format preferences:
   • Lead with the recommendation
   • Explain the reasoning
   • Note trade-offs or risks
   • Suggest next steps
6. Include domain expertise framing — What the GPT should be expert in based on the project's domain
7. Set guardrails:
   • Don't write production code (pseudocode/wireframes OK)
   • Don't contradict established conventions without flagging it
   • Don't make assumptions about user research — ask
   • Always consider mobile-first
   • Always consider accessibility
8. End with persona calibration — How the GPT should "feel" in conversation (collaborative peer, not lecturer)

Phase 4 — Write All Files

1. Create the output directory if it doesn't exist
2. Write all 21 files
3. Report completion with a summary of what was generated

Rules

1. No code dumps — This is for strategic collaboration. Short code snippets (≤5 lines) are OK to illustrate a pattern, but never paste full files.
2. Optimize for retrieval — GPT knowledge files are chunked. Front-load key info. Use clear headings. Avoid burying important facts in paragraphs.
3. Be concrete, not generic — Every file should contain actual project-specific information, not boilerplate advice.
4. Cross-reference — Files should reference each other (e.g., "See 04-DESIGN-SYSTEM.md for token details").
5. Current state — Document what IS, not what should be. Note gaps or known issues where relevant.
6. Custom instructions budget — The 20-CUSTOM-INSTRUCTIONS.md file MUST be ≤7,500 characters. Count carefully. This is a hard limit from OpenAI.
7. Repo-agnostic skill — This skill must work on ANY project. Do not hardcode paths, entity names, or project-specific knowledge into this skill file. All project knowledge comes from Phase 1 discovery.
8. Markdown only — All output files are .md. No other formats.
9. File naming — Use the exact filenames from the manifest. Zero-padded numbers for sort order.
10. No secrets — Never include API keys, tokens, connection strings, or credentials in any output file.