Day 14: Building a Complete Operations Knowledge System with goose Skills
The Winter Festival succeeded because of the expertise of its team. Every department had developed its own workflows, escalation paths, and operational knowledge, but none of it was documented in a way that could scale. With three neighboring towns requesting help to run their own festivals, the Director needed a system that could capture this expertise and make it reusable.
This challenge introduced goose Skills, a mechanism for encoding domain knowledge into structured, discoverable, and portable expertise. Instead of producing a static manual, the goal was to build a living operational system that goose can load and apply automatically whenever a coordinator needs guidance.
The Challenge: Capture Operational Knowledge as a Skill System
The mission was to create a festival‑operations skill that consolidates the knowledge of four core team members:
- Customer experience workflows
- Security and vendor protocols
- Lost and found procedures
- Marketing and communications guidelines
The skill needed to be actionable, structured, and discoverable by goose. It also required supporting files such as checklists, templates, decision trees, and scripts to form a complete operational system.
Understanding goose Skills
A goose Skill is a markdown file with YAML frontmatter that teaches goose a domain. Skills are automatically discovered at session start and loaded when relevant. They differ from recipes because they provide knowledge rather than execute tasks.
Skills include:
- Core knowledge (SKILL.md)
- Checklists
- Templates
- Decision trees
- Scripts
- Recipes for generating new skills
This allows a skill to function as a modular knowledge system rather than a single document.
The Full Skills Architecture
I did not build a single skill.
I built a multi‑skill operational knowledge architecture with layered expertise, reusable components, and cross‑skill interoperability.
Below is my complete directory structure:
+---eriperspective-ai-engineering
| debugging-checklist.md
| decision-trees.md
| engineering-style.md
| problem-analysis.md
| SKILL.md
|
+---festival-operations
| | decision-trees.md
| | SKILL.md
| |
| +---checklists
| | closing.md
| | opening.md
| | quick-reference.md
| |
| +---recipes
| | skill-generator.md
| |
| +---scripts
| | cleanup.sh
| |
| \---templates
| incident-report.md
|
+---lost-and-found
| SKILL.md
|
+---marketing-communications
| SKILL.md
|
+---security-protocols
| SKILL.md
|
\---volunteer-management
SKILL.md
Six independent skills, each representing a domain of festival operations or engineering practice.
Technical Architecture Diagram
┌──────────────────────────────────────────┐
│ goose Skills Knowledge Base │
└──────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────┐
│ Multi‑Skill Operational System │
└──────────────────────────────────────────────┘
│
┌──────────────────────────────────────────────────────────────────────────┐
│ │
▼ ▼
┌──────────────────────────┐ ┌──────────────────────────┐
│ eriperspective-ai- │ │ festival-operations │
│ engineering (Personal OS)│ │ (Primary Domain Skill) │
└──────────────────────────┘ └──────────────────────────┘
│ │
│ │
▼ ▼
┌──────────────────────────┐ ┌──────────────────────────┐
│ Debugging workflows │ │ Customer experience │
│ Decision trees │ │ Security protocols │
│ Engineering style │ │ Vendor management │
│ Problem analysis │ │ Lost and found workflows │
└──────────────────────────┘ │ Marketing communications │
└──────────────────────────┘
│
▼
┌─────────────────────────────────────────────┐
│ Department‑Specific Operational Skills │
└─────────────────────────────────────────────┘
│
┌──────────────────────┬────────────────────────┬────────────────────────┬──────────────────────┐
▼ ▼ ▼ ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ lost-and-found │ │ marketing- │ │ security- │ │ volunteer- │
│ SKILL.md │ │ communications │ │ protocols │ │ management │
└──────────────────┘ └──────────────────┘ └──────────────────┘ └──────────────────┘
This diagram reflects the actual structure: a layered, modular knowledge system with a personal engineering OS, a primary operational skill, and multiple departmental sub‑skills.
Achievement Summary
All four challenge tiers were completed:
I progressed through every Goose challenge tier: Beginner, Intermediate, Advanced, and Ultimate, building a full multi‑skill system and completing my personal eripersoective AI Engineering OS skill at the highest level. This skill functions consistently in both Goose CLI and Goose Desktop environments.
Beginner Level Completed
Created a new Goose skill with proper YAML frontmatter
Added multiple operational sections
Added supporting files like quick‑reference checklists
Formatted the skill for clarity
Successfully tested the skill in Goose
Intermediate Level Completed
Built multiple related skills (one per department)
Added templates and structured supporting files
Included decision trees for complex scenarios
Ensured the skills were compatible across Goose environments
Advanced Level Completed
Created skills that reference each other
Added runnable supporting scripts
Built a skill‑generator recipe
Added a skill‑testing checklist to validate quality
Ultimate Level Completed
Built the eriperspective AI Engineering OS skill
Captured my engineering philosophy, learning style, UI aesthetic, and immersive‑tech interests
Added decision trees, checklists, recipes, and templates
Created a complete personal engineering OS that Goose can use to think and reason like mechecklists.
Created Erica’s Engineering OS, a complete personal operating system capturing engineering philosophy, workflows, debugging processes, and decision‑making patterns.
This is a full enterprise‑grade knowledge system.
Erica’s Engineering OS
As part of the Ultimate Challenge, you built a complete engineering operating system containing:
- Debugging workflows
- Problem analysis frameworks
- Decision trees
- Engineering style guidelines
- Learning philosophy
This OS defines a consistent engineering identity and provides a reusable framework for problem solving and decision making.
goose Skills are just files on disk its knowledge‑engineering stack that supports discovery, loading, and execution inside goose.
Technical Stack for the Goose Skills System
goose Runtime Environment
This is the core execution layer.
- goose CLI (v1.17.0+)
- goose Desktop (optional, compatible)
- Skills extension enabled
- Developer extension enabled
This environment is responsible for:
- Skill discovery
- Skill loading
- Contextual relevance matching
- Applying skill knowledge to user queries
Filesystem‑Based Skill Architecture
Skills are stored as structured directories:
~/.config/goose/skills/
./.goose/skills/
This provides:
- Namespacing
- Priority‑based skill resolution
- Cross‑skill interoperability
- Portability across machines
Markdown + YAML Knowledge Format
Every skill uses:
- YAML frontmatter for metadata
- Markdown for structured knowledge
- Subdirectories for modular components
This stack enables:
- Human‑readable documentation
- Machine‑interpretable metadata
- Extensibility through supporting files
Skill Submodules
My system uses multiple submodules:
- checklists/
- templates/
- recipes/
- scripts/
- decision‑trees.md
- debugging‑checklist.md
These act as:
- Operational modules
- Reusable components
- Knowledge primitives
- Execution helpers (scripts)
Shell Script Execution Layer
Included runnable scripts such as:
cleanup.sh
This introduces:
- POSIX shell compatibility
- Script execution via goose Developer extension
- Automated maintenance workflows
Cross‑Skill Knowledge Graph
My architecture forms a knowledge graph, not a flat set of files.
Skills reference each other implicitly through:
- Shared domains
- Overlapping terminology
- Goose’s relevance engine
This allows:
- Multi‑skill reasoning
- Department‑specific overrides
- Hierarchical expertise
Tech Stack
| Layer | Technology | Purpose |
|---|---|---|
| Runtime | goose CLI + Skills extension | Skill discovery and execution |
| Storage | Filesystem directories | Namespaced skill organization |
| Format | Markdown + YAML | Human and machine readable knowledge |
| Modules | Checklists, templates, scripts, decision trees | Operational components |
| Execution | Shell scripts | Automation and maintenance |
| Reasoning | goose relevance engine | Contextual skill loading |
My Final Thoughts
Day 14 produced a complete operational knowledge system built on goose Skills. The festival‑operations skill captures the expertise of the entire team and makes it accessible to any future coordinator. The supporting files, decision trees, templates, and scripts transform the skill into a practical, scalable operational system.
Day 14: Completed Operational knowledge: Captured. Skill ecosystem: Fully established.
This post is part of my Advent of AI journey, AI Engineering: Advent of AI with goose Day 14.
Follow along for more AI Engineering Adventures with Eri!
Top comments (0)