AI Engineering: Advent of AI with goose Day 14 - Complete Operations System

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

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!