Universal Creation Framework

Universal Creation Framework — Mega-Skill

The meta-pattern beneath all creation: Diverge then converge. Commit resources progressively as uncertainty decreases. Validate through prototyping before full commitment. Separate the act of creation from the act of evaluation. This framework codifies that meta-pattern into a machine-readable format any AI platform can execute.

0. How to Use This Skill

This skill operates as a universal entry point for any creative or technical project. It does not replace domain expertise — it orchestrates it. The framework:

1. Classifies your project type using the decision tree in Section 1.
2. Routes to the appropriate domain workflow (Section 3).
3. Enforces six universal phases with explicit quality gates (Section 2).
4. Adapts depth and formality based on scale, risk, and complexity (Section 1.2).
5. Leverages platform-specific capabilities through thin adapter guidance (Section 5).

Platform invocation:

• Claude / Claude Code: Place this file in .claude/skills/universal-creation-framework/SKILL.md
• OpenAI Codex: Place in .agents/skills/universal-creation-framework/SKILL.md
• Manus: Paste the relevant section as a natural-language task description
• ChatGPT: Use as a Custom GPT system prompt or upload as a knowledge file
• Gemini / Firebase Studio: Reference as airules.md or project instructions
• Any platform: Copy the relevant phase and domain section into your system prompt

1. Project Classifier — Entry Point

1.1 Primary Classification (What is the primary output?)

Answer the first applicable question to determine your domain:

1.2 Secondary Classification (How deep should we go?)

Evaluate three dimensions to determine workflow depth:

Scale:

• PERSONAL — Solo creator, no formal governance needed
• TEAM — 2–20 people, lightweight coordination required
• ENTERPRISE — 20+ people or external stakeholders, full governance required

Risk:

• EXPERIMENTAL — Failure is acceptable and informative
• LOW — Failure has minor consequences
• MEDIUM — Failure has significant but recoverable consequences
• HIGH — Failure has major financial, reputational, or safety consequences
• SAFETY-CRITICAL — Failure could harm people (medical, aerospace, infrastructure)

Complexity:

• LIGHT — Single-phase or single-deliverable work (birthday party, simple blog post)
• STANDARD — Multi-phase work with clear dependencies (mobile app, marketing campaign)
• DEEP — Multi-team, multi-year, or multi-domain work (operating system, new medicine)

Depth matrix:

2. The Six Universal Phases

Every project — from a birthday party to an operating system — follows this structure. Depth and formality adapt; the structure does not.

Phase 1 — Discovery & Research

Purpose: Understand the problem space before committing to a solution.

Universal activities:

• Define the problem statement in one sentence
• Identify the primary stakeholders and their needs
• Survey the existing landscape (competitors, precedents, prior art)
• Surface key constraints (time, budget, technology, regulation, physics)
• Assess initial feasibility
• Document what success looks like

Domain adaptations:

• Software: Requirements gathering, user research, technical landscape survey
• Physical-Creative: Reference research, cultural/historical context, material feasibility
• Media: Audience analysis, competitive content audit, platform research
• Scientific: Literature review (use Elicit, Semantic Scholar, PubMed), hypothesis formulation
• Business: Market analysis, customer discovery, competitive intelligence
• Events: Vision definition, venue research, stakeholder alignment

Recommended tools by platform:

• Perplexity Deep Research (138M+ papers via Elicit integration)
• Claude with web search for competitive analysis
• Google Scholar, PubMed, ChEMBL for scientific domains
• SimilarWeb, SEMrush for market/content research

Gate 1 — Go/Hold/Kill decision:

Phase 2 — Scoping & Planning

Purpose: Define exactly what will be built, how, by whom, and when.

Critical principle: Planning should consume approximately 60–75% of total effort for optimal outcomes. Premature execution is the single most common cause of project failure in AI-assisted work. (Source: Addy Osmani's AI-assisted development research)

Universal activities:

• Define scope boundaries (what is IN and explicitly what is OUT)
• Create a work breakdown structure (WBS) with dependencies
• Estimate resources: time, compute, cost, people
• Select the technology/methodology stack
• Identify and document risks with mitigations
• Define "done" criteria for each deliverable
• Establish communication and review cadence
• Create the project timeline with milestones

Domain adaptations:

• Software: Architecture decision records (ADRs), API contracts, data models, security threat model
• Physical-Creative: Material specifications, production timeline, supplier research, safety review
• Hybrid: Synchronization checkpoints where physical and digital streams must align; note that physical components cannot be patched after manufacturing — lock physical decisions earlier
• Scientific: Experimental design, statistical power analysis, IRB/ethics review if human subjects
• Business: Business model canvas, financial projections, go-to-market strategy, legal structure
• Events: Budget breakdown, vendor contracts, contingency plans, run-of-show document

Gate 2 criteria:

Phase 3 — Design & Prototyping

Purpose: Create tangible proof-of-concept before full resource commitment.

Universal principle: Never commit full resources to an unvalidated concept. A prototype that fails is a success — it saved you from building the wrong thing.

Universal activities:

• Create the lowest-fidelity prototype that can answer your riskiest question
• Test the prototype against Gate 3 criteria
• Iterate until the concept is validated
• Document design decisions and rationale
• Obtain stakeholder approval before proceeding

Domain adaptations:

• Software: Wireframes → clickable prototype → technical spike → MVP; use Stitch for UI-to-code
• Physical-Creative: Sketches → mood boards → material samples → scale model → pilot piece
• Media: Outline → script → storyboard → pilot episode or sample chapter
• Scientific: Protocol draft → pilot study → statistical validation → peer pre-review
• Business: Business model canvas → landing page test → customer interviews → financial model
• Events: Venue walkthrough → vendor quotes → mock run-of-show

Recommended tools:

• Google Stitch: Text/image to high-fidelity UI in minutes
• Figma + Claude: Design system generation
• Claude Artifacts: Interactive HTML/React prototypes
• Manus: End-to-end prototype generation from description

Gate 3 criteria:

Phase 4 — Production & Development

Purpose: Full-scale creation with iterative cycles and quality checkpoints.

Universal principle: Work in manageable units with clear dependencies. Follow the universal "prototype → test → iterate" loop at every scale.

Universal activities:

• Break work into units of ≤2 weeks (sprints, chapters, episodes, batches)
• Implement with continuous integration of feedback
• Conduct milestone reviews at each unit boundary
• Track progress against the plan; escalate deviations early
• Maintain a living artifact tracker (decisions, blockers, progress)
• Enforce mandatory human checkpoints after every 3–4 AI iterations

Domain adaptations:

• Software: Sprint-based development, TDD, code review, CI/CD pipeline; use Claude Code or Codex for implementation, Jules for async bug fixes
• Physical-Creative: Asset production with periodic review; separate AI-as-ideation from AI-as-production; note AI images lack individual layers (use masking workflows); upscale for print resolution
• Media: Asset production → rough cut/draft → review → polish; multi-format adaptation from single source
• Scientific: Data collection → analysis → interpretation → manuscript; enforce reproducibility documentation
• Business: Build → measure → learn cycles; CRM configuration, brand asset production
• Events: Vendor coordination, logistics execution, rehearsals

Context engineering for long production phases:

• Use compaction when context window approaches limit (summarize + reinitiate)
• Use structured note-taking (NOTES.md or artifact-tracker) for persistent state
• Use sub-agent delegation for deep exploration tasks (each sub-agent returns 1,000–2,000 token summary)
• Enforce just-in-time retrieval — maintain file paths and queries, not full content in context

Gate 4 criteria:

Phase 5 — Testing & Validation

Purpose: Domain-appropriate quality assurance before release.

Four-layer QA architecture:

Layer 1 — Deterministic validation (run first, no AI tokens consumed):

• Software: Compile, lint, type-check, unit tests, integration tests, security scan, accessibility audit
• Content: Plagiarism check, readability score, fact extraction, brand compliance
• Design: WCAG compliance, responsive layout verification, print resolution check
• Science: Statistical tests, data integrity checks, reproducibility verification
• Physical: Dimensional tolerance check, material compatibility, safety compliance

Layer 2 — AI-as-judge evaluation (semantic quality): Score each output 1–5 on these seven dimensions:

1. Accuracy/Faithfulness — Does it correctly represent facts and sources?
2. Relevance — Does it address the actual need?
3. Completeness — Are all required elements present?
4. Coherence — Is it internally consistent and logically structured?
5. Originality — Does it add genuine value beyond recombination?
6. Bias/Fairness — Are perspectives balanced and assumptions examined?
7. Actionability — Can the intended audience act on this?

Minimum acceptable score: 4/5 on Accuracy, 3/5 on all others.

Layer 3 — Human review at gates (ConSiDERS framework):

• Consistency: Same criteria applied across all outputs
• Scoring criteria: Explicit rubric shared with reviewers
• Differentiating: Rubric distinguishes good from excellent
• Ethical considerations: Bias, privacy, safety reviewed
• Reproducibility: Another reviewer would reach same conclusion
• Scalability: Review process can handle volume

Layer 4 — Continuous monitoring (post-launch):

• Track drift, performance degradation, and anomalies
• Mandatory human review after 3–4 AI iterations without intervention
• Domain-specific: A/B testing for software/media, citation provenance for science, brand compliance for business

Gate 5 criteria:

Phase 6 — Launch & Iteration

Purpose: Release, monitor, and feed learnings back into the system.

Universal activities:

• Execute the launch/release/publication/deployment plan
• Activate monitoring and feedback collection
• Conduct post-launch retrospective (within 2 weeks)
• Prioritize iteration backlog based on observed outcomes
• Update this SKILL.md based on observed failures — treat skills as living code

Domain adaptations:

• Software: Phased rollout, feature flags, error monitoring, performance dashboards
• Physical-Creative: Exhibition, publication, distribution; document production notes for future runs
• Media: Multi-platform distribution, SEO optimization, analytics tracking, audience feedback
• Scientific: Peer review submission, preprint posting, data/code release, replication invitation
• Business: Go-to-market execution, PR/communications, customer onboarding, KPI tracking
• Events: Day-of execution, post-event survey, vendor debrief, documentation for next edition

Skill improvement protocol (after every project):

1. List every instruction in this SKILL.md that the AI followed correctly without being told
2. Remove those instructions (the model no longer needs them)
3. List every failure mode observed
4. Add specific instructions to prevent those failures
5. Test the updated skill with a fresh AI instance before deploying

Gate 6 criteria:

3. Domain Skill Modules

3.1 SOFTWARE — Apps, APIs, Platforms, Operating Systems, Tools

When to use: Primary output is running code. Includes: mobile apps, web apps, APIs, CLIs, operating systems, compilers, databases, developer tools, AI agents, automation workflows.

Phase adaptations:

• Phase 1: User stories, technical landscape, security threat model
• Phase 2: Architecture Decision Records (ADRs), API contracts, data models, test strategy
• Phase 3: Wireframes → technical spike → MVP; validate with real users
• Phase 4: TDD, code review, CI/CD, sprint ceremonies
• Phase 5: Automated test suite, security scan, performance benchmarks, accessibility audit
• Phase 6: Phased rollout, feature flags, SLOs, runbook

Quality criteria:

• All tests passing (unit, integration, e2e)
• No critical/high security vulnerabilities (OWASP Top 10)
• Code review approval from qualified reviewer
• Performance benchmarks met (define specific thresholds)
• Accessibility: WCAG 2.1 AA minimum
• Documentation: README, API docs, architecture diagram

Recommended tools:

• Implementation: Claude Code, OpenAI Codex, Cursor, Windsurf
• Async tasks: Google Jules (up to 60 concurrent on Ultra tier)
• Research: Perplexity for technology decisions
• Design: Google Stitch for UI generation
• Backend: Firebase Studio, Google Cloud Run
• Testing: Claude Code for test generation, Jules for bug fixes

Anti-patterns:

• Starting implementation before architecture is documented
• Skipping the test strategy in Phase 2
• Using AI to generate tests without reviewing them
• Deploying without monitoring in place
• Treating AI-generated code as reviewed code

Common deliverables by phase:

1. PRD, user stories, technical landscape doc
2. Architecture diagram, ADRs, data model, API spec, test plan
3. Wireframes, technical spike, MVP
4. Working software with tests, CI/CD pipeline
5. Test report, security audit, performance report
6. Deployed application, runbook, monitoring dashboard

3.2 PHYSICAL-CREATIVE — Art, Architecture, Products, Fashion, Industrial Design

When to use: Primary output is a physical object or experience. Includes: paintings, sculptures, buildings, furniture, clothing, jewelry, vehicles, consumer products, packaging.

Critical asymmetry: Physical components cannot be "patched" after production. Lock physical design decisions earlier than digital ones. Material selection, structural decisions, and manufacturing tolerances must be finalized before production begins.

Phase adaptations:

• Phase 1: Reference research (historical, cultural, material), mood boards, constraint mapping
• Phase 2: Material specifications, production timeline, supplier research, safety/regulatory review
• Phase 3: Sketches → CAD/technical drawings → material samples → scale model → pilot piece
• Phase 4: Production with periodic quality checks; separate AI-as-ideation from AI-as-production
• Phase 5: Dimensional tolerance, material compatibility, safety compliance, user testing
• Phase 6: Exhibition/distribution, documentation, production notes for future runs

AI-specific notes:

• AI-generated images lack individual layers — use masking workflows for production
• Upscale to minimum 300 DPI for print production
• Use AI for ideation and reference generation, not final production files
• Physical safety standards vary by domain — always verify with domain expert

Quality criteria:

• Dimensional tolerances within specification
• Material compatibility verified
• Safety compliance documented
• Prototype user-tested
• Production documentation complete

3.3 HYBRID — Physical + Digital Products

When to use: Project requires both physical and digital deliverables that must work together. Includes: board games with apps, illustrated books with AR, smart home devices, wearables, interactive installations.

Critical principle: Establish explicit synchronization checkpoints where physical and digital streams must align. Physical decisions must be locked before digital work that depends on them can proceed.

Synchronization checkpoints:

• After Phase 2: Physical specs locked → digital team can begin dependent work
• After Phase 3: Physical prototype validated → digital prototype can reference real dimensions
• After Phase 4: Physical production complete → digital integration testing can begin
• After Phase 5: Both streams validated → combined user testing

Anti-patterns:

• Letting digital work proceed on assumptions about physical specs
• Discovering physical/digital incompatibility in Phase 5
• Not documenting which decisions are physical-locked vs. digital-flexible

3.4 MEDIA — Content, Video, Podcast, Books, Courses, Social

When to use: Primary output is content consumed by an audience. Includes: YouTube videos, podcasts, books, articles, courses, social media campaigns, newsletters, films, music.

Unique capability: Multi-format adaptation from single source content. One well-structured piece of content can become: long-form article, video script, social posts, newsletter, podcast outline, slide deck.

Platform-specific formatting rules:

• YouTube: SEO-optimized title/description, chapters at 10-min intervals, thumbnail A/B test
• TikTok/Reels: Hook within first 3 seconds, vertical format, captions mandatory
• Instagram: Carousel for depth, single image for emotion, hashtag strategy (5–10 relevant)
• Podcast: RSS-ready, transcription for SEO, show notes with timestamps
• Newsletter: Subject line A/B test, preview text optimization, plain-text fallback
• LinkedIn: Professional tone, data-backed claims, engagement question at end

Quality criteria:

• Readability score appropriate for target audience
• Fact claims verified with sources
• Brand voice consistency score ≥ 4/5
• Platform format requirements met
• Engagement metrics baseline established

3.5 SCIENTIFIC — Research, Engineering, Medicine, Technology Standards

When to use: Primary output is new knowledge, validated protocols, or technology standards. Includes: academic papers, clinical trials, engineering specifications, coding language design, protocol standards.

Epistemic rigor requirements:

• Distinguish AI prediction from AI understanding in all outputs
• Require provenance tracking for all factual claims
• Mandate reproducibility documentation
• Never present AI-generated hypotheses as validated findings

Phase adaptations:

• Phase 1: Literature review via Elicit (138M+ papers), hypothesis formulation, gap analysis
• Phase 2: Experimental design, statistical power analysis, IRB/ethics review, pre-registration
• Phase 3: Pilot study, protocol validation, instrument calibration
• Phase 4: Data collection, analysis, interpretation; enforce lab notebook discipline
• Phase 5: Statistical validation, peer pre-review, reproducibility check, citation audit
• Phase 6: Peer review submission, preprint, data/code release, replication invitation

Quality criteria:

• All claims traceable to primary sources
• Statistical methods appropriate and pre-specified
• Reproducibility package (data + code + environment) complete
• Peer pre-review completed
• Conflicts of interest disclosed

3.6 BUSINESS — Ventures, Brands, Services, Operations

When to use: Primary output is a business system, brand identity, or service design. Includes: startups, brand development, service design, marketing systems, operational workflows, SaaS platforms.

Phase adaptations:

• Phase 1: Market analysis, customer discovery, competitive intelligence, regulatory landscape
• Phase 2: Business model canvas, financial projections, legal structure, go-to-market strategy
• Phase 3: Landing page test, customer interviews, financial model validation, brand prototype
• Phase 4: Build → measure → learn cycles; CRM configuration, brand asset production
• Phase 5: Market validation, financial model stress test, brand compliance audit
• Phase 6: Go-to-market execution, PR/communications, customer onboarding, KPI tracking

Quality criteria:

• Business model validated with real customer conversations
• Financial model stress-tested with pessimistic scenarios
• Legal structure reviewed by qualified counsel
• Brand identity consistent across all touchpoints
• Data privacy compliance documented (GDPR, CCPA as applicable)

3.7 EVENTS — Events, Experiences, Personal Projects

When to use: Primary output is an event, experience, or personal project. Includes: conferences, weddings, exhibitions, travel, personal development projects.

Workflow mode: Express or Standard (rarely Rigorous). Use plain language, template-driven approaches, and simplified gates.

Phase adaptations:

• Phase 1: Vision definition, venue research, stakeholder alignment, budget envelope
• Phase 2: Budget breakdown, vendor shortlist, timeline, contingency plans
• Phase 3: Venue walkthrough, vendor quotes, mock run-of-show
• Phase 4: Vendor coordination, logistics execution, rehearsals
• Phase 5: Dress rehearsal, contingency review, day-of checklist
• Phase 6: Day-of execution, post-event survey, vendor debrief

Human judgment is irreplaceable for: taste, atmosphere, interpersonal dynamics, and crisis management.

4. Context Engineering Principles

These principles apply to ALL platforms and ALL domains. They determine how effectively the AI uses its finite attention budget.

4.1 Minimal High-Signal Context

Never load instructions the AI already knows. Each skill encodes only domain-specific procedural knowledge the model wouldn't know otherwise.

• Project facts → CLAUDE.md / AGENTS.md / project instructions (always loaded)
• Specialized workflows → skills (loaded on demand)
• Reference material → separate files (loaded only when explicitly needed)

4.2 Just-in-Time Retrieval

Maintain lightweight identifiers (file paths, search queries, URLs) and use tools to dynamically load data at runtime. Never front-load all project context.

# Good: reference, don't embed
See: ./references/api-spec.yaml
Run: grep -r "authentication" ./src

# Bad: paste entire files into context
[3,000 lines of API spec pasted here]

4.3 Structured Note-Taking for Long-Horizon Tasks

Maintain a persistent NOTES.md or artifact-tracker outside the context window:

# Project State — [Project Name]
Last updated: [date]

## Current phase: [phase name]
## Completed: [list]
## In progress: [list]
## Blocked: [list with blockers]
## Key decisions: [ADRs or equivalent]
## Next actions: [prioritized list]

4.4 Sub-Agent Delegation

For deep exploration tasks, fork to sub-agents with clean context windows. Each sub-agent may use tens of thousands of tokens internally but returns a condensed summary of 1,000–2,000 tokens to the main agent.

4.5 Compaction for Long Sessions

When context window approaches limit:

1. Pass message history to model for summarization
2. Preserve: architectural decisions, unresolved issues, implementation details
3. Discard: redundant tool outputs, superseded drafts, raw search results
4. Reinitiate with compressed context + 5 most recently accessed files

4.6 The 3–4 Iteration Rule

Research shows diminishing returns and compounding error risk after 3–4 AI iterations without human intervention. Enforce mandatory human checkpoints at this threshold.

4.7 Start Minimal, Add Based on Failures

"Start by testing a minimal prompt with the best model available to see how it performs on your task, and then add clear instructions and examples to improve performance based on failure modes found during initial testing." — Anthropic Engineering

Never add instructions preemptively. Add them only when you observe a specific failure.

5. Platform-Specific Guidance

5.1 Claude / Claude Code

Skill location: .claude/skills/universal-creation-framework/SKILL.md Always-loaded context: CLAUDE.md (project conventions) Context budget: First 5,000 tokens per skill within 25,000-token combined budget after compaction Unique strengths: Extended thinking, XML-structured instructions, richest MCP ecosystem, Artifacts for interactive outputs Invocation: Skills auto-activate based on description match; explicit invocation via /skill-name Best for: Complex reasoning, nuanced writing, multi-step research, interactive prototypes

# CLAUDE.md template for this framework
project: [name]
domain: [SOFTWARE|PHYSICAL|HYBRID|MEDIA|SCIENTIFIC|BUSINESS|EVENTS]
phase: [1-6]
scale: [PERSONAL|TEAM|ENTERPRISE]
risk: [EXPERIMENTAL|LOW|MEDIUM|HIGH|SAFETY-CRITICAL]
complexity: [LIGHT|STANDARD|DEEP]
artifact_tracker: ./NOTES.md

5.2 OpenAI Codex

Skill location: .agents/skills/universal-creation-framework/SKILL.md Invocation: Explicit via $universal-creation-framework syntax Unique strengths: Cloud-based parallel execution, two-phase sandbox (network during setup, offline during execution), Automations for scheduled work Parallel tasks: Up to 60 concurrent on appropriate tier Best for: Autonomous coding tasks, parallel test generation, scheduled background work

# .agents/skills/universal-creation-framework/agents/openai.yaml
name: universal-creation-framework
description: Universal project lifecycle framework for all domains
invocation: explicit
parallel: true
sandbox: isolated

5.3 Google Ecosystem

Chain: Stitch (design) → Firebase Studio / Antigravity (development) → Firebase (backend) → Cloud Run (production) Jules: Async coding tasks via GitHub integration, up to 60 concurrent tasks Gemini: 1M+ token context window enables loading entire codebases Stitch adapter: .stitch/DESIGN.md stores design system tokens Firebase adapter: airules.md configures Firebase Studio behavior Best for: Full-stack Google Cloud projects, large codebase analysis, parallel async development

5.4 ChatGPT / Custom GPTs

Mapping: Core instructions → GPT system prompt; domain skills → uploadable knowledge files Canvas: Use for visual code/writing collaboration Best for: Consumer-facing applications, broad accessibility, GPT Store distribution

5.5 Manus

Mapping: Natural-language task descriptions (no file-based skill system) Unique strengths: Highest-autonomy tier — plans, executes, and delivers end-to-end without intervention Best for: Complete project execution from description, multi-agent orchestration

Manus task template:

Project: [name]
Domain: [domain]
Phase: [current phase]
Context: [brief project state]
Task: [specific deliverable needed]
Quality criteria: [from Phase N gate]
Constraints: [time, budget, technical]

5.6 Perplexity

Role in framework: Primary research engine for Phase 1 (Discovery) Deep Research: Synthesizes 138M+ papers via Elicit integration Best for: Literature review, competitive analysis, technology research, fact verification

5.7 Apple Xcode + Claude Agent SDK

Integration: Xcode 26.3+ exposes capabilities via MCP Agent SDK phases: Gather Context → Plan → Execute → Verify (mirrors framework phases) Best for: Native iOS/macOS development with AI assistance

6. The Interoperability Stack

┌─────────────────────────────────────────────────────┐
│                  SKILLS LAYER                        │
│  What to do — domain workflows, phase gates, QA     │
│  (This document + domain sub-skills)                │
├─────────────────────────────────────────────────────┤
│                   MCP LAYER                          │
│  Tool access — GitHub, Figma, Jira, databases,      │
│  cloud services, any API (10,000+ MCP servers)      │
├─────────────────────────────────────────────────────┤
│                   A2A LAYER                          │
│  Agent collaboration — multi-agent orchestration    │
│  Agent Cards at /.well-known/agent.json             │
│  (150+ organizations including Adobe, SAP, SF)      │
└─────────────────────────────────────────────────────┘

Skills + MCP + A2A = Complete stack:

• Skills define WHAT to do
• MCP provides TOOL ACCESS
• A2A enables AGENT COLLABORATION

7. Quality Assurance Checklists

Universal Pre-Launch Checklist

• All Phase 1–5 gate criteria documented and signed off
• Layer 1 deterministic validation: all checks pass
• Layer 2 AI scoring: all dimensions ≥ minimum threshold
• Layer 3 human review: ConSiDERS framework applied
• Monitoring/feedback system: active
• Rollback plan: documented and tested
• Stakeholder sign-off: obtained
• Artifact tracker: complete and archived
• Retrospective: scheduled

Skill Improvement Checklist (post-project)

• List instructions followed correctly without being told → remove them
• List observed failure modes → add specific instructions
• Test updated skill with fresh AI instance
• Version the updated skill (git tag)
• Share improvements with team

8. Prompt Templates

Project Kickoff Template

I'm starting a new project. Please activate the Universal Creation Framework.

Project name: [name]
One-sentence description: [description]
Primary output type: [software/physical/media/scientific/business/events/hybrid]
Scale: [personal/team/enterprise]
Risk level: [experimental/low/medium/high/safety-critical]
Timeline: [duration]
Key constraints: [list]

Please:
1. Confirm the domain classification
2. Identify the appropriate workflow depth (Express/Standard/Rigorous/Safety)
3. Run Phase 1 — Discovery & Research
4. Present Gate 1 criteria and ask for confirmation before proceeding

Phase Transition Template

We are completing Phase [N] of the Universal Creation Framework.

Project: [name]
Domain: [domain]
Current phase output: [brief summary]

Please:
1. Evaluate Gate [N] criteria (list each criterion and status)
2. Identify any criteria not yet met
3. Recommend: GO / HOLD / KILL with rationale
4. If GO: outline Phase [N+1] plan

QA Evaluation Template

Please evaluate the following output using the Universal Creation Framework QA system.

Output type: [type]
Domain: [domain]
Output: [paste output or reference file]

Evaluate:
1. Layer 1: List all deterministic checks applicable to this output type
2. Layer 2: Score 1-5 on each of the 7 dimensions with specific evidence
3. Layer 3: Identify what human review is needed per ConSiDERS
4. Overall recommendation: PASS / REVISE / REJECT with specific improvements

Skill Update Template

Post-project retrospective for Universal Creation Framework skill update.

Project completed: [name]
Domain: [domain]
Duration: [duration]

Please analyze:
1. Which framework instructions did the AI follow correctly without being told? (candidates for removal)
2. What failure modes were observed? (candidates for new instructions)
3. Which gate criteria were most/least useful?
4. What domain-specific patterns should be added?
5. Draft the specific SKILL.md edits needed

9. Anti-Patterns (Universal)

These failure modes appear across all domains and all platforms:

10. Future-Proofing Mechanisms

This framework is designed to evolve. Three mechanisms ensure longevity:

New domains: Create a new SKILL.md in domains/ and update the project classifier. No existing skills need modification. New skills add only ~100 tokens of metadata overhead.

Platform changes: Absorbed by the adapter layer (Section 5). When a new AI platform emerges, add a thin adapter. Core skills remain unchanged.

Model improvements: Following Anthropic's guidance — "harnesses should be frequently questioned as models improve." Run the Skill Improvement Checklist after every project. Remove instructions the model follows correctly without being told. The framework gets leaner and more powerful over time.

References

1. Anthropic Engineering. "Effective Context Engineering for AI Agents." Sep 29, 2025. https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
2. Anthropic. "Claude Skills." https://claude.com/skills
3. Anthropic. "Configuration and Multi-File Skills." https://claude.com/resources/tutorials/configuration-and-multi-file-skills
4. OpenAI. "Codex Best Practices." https://developers.openai.com/codex/learn/best-practices
5. OpenAI. "Codex Skills." https://developers.openai.com/codex/skills
6. Google Labs. "Stitch Skills." https://github.com/google-labs-code/stitch-skills
7. travisvn. "Awesome Claude Skills." https://github.com/travisvn/awesome-claude-skills (11.3k stars)
8. Anthropic. "The Complete Guide to Building Skills for Claude." https://resources.anthropic.com/hubfs/The-Complete-Guide-to-Building-Skill-for-Claude.pdf
9. Cooper, R.G. "Stage-Gate® New Product Development Process." Product Development Institute.
10. Osmani, A. "AI-Assisted Development Research." (Planning = 60-75% of effort finding)
11. ACL 2024. "ConSiDERS-The-Human Framework for Human Evaluation."
12. Linux Foundation. "Agentic AI Foundation — MCP and A2A Standards."
13. Google. "Agent-to-Agent (A2A) Protocol v0.3." April 2025.
14. McKinsey. "Rule-based workflow engines outperform letting AI decide 'what comes next'."