Skip to content

Latest commit

 

History

History
229 lines (179 loc) · 13.2 KB

File metadata and controls

229 lines (179 loc) · 13.2 KB
title tibsfox.com — Learning to Work Effectively with AI
layer meta
path index.md
summary The entry point and narrative spine connecting mathematical foundations through practical application to community contribution.
cross_references
path relationship description
foundations/index.md
gateway-to
Layer 1 — Mathematical and philosophical foundations
path relationship description
principles/index.md
gateway-to
Layer 2 — Design principles and patterns
path relationship description
framework/index.md
gateway-to
Layer 3 — GSD Skill Creator framework documentation
path relationship description
applications/index.md
gateway-to
Layer 4 — Real-world applications and educational packs
path relationship description
community/index.md
gateway-to
Layer 5 — Community participation and skill exchange
path relationship description
meta/content-map.md
parallel
Complete inventory of all published content
reading_levels
glance scan
An educational ecosystem for learning to work effectively with AI, connecting five layers from mathematical foundations to community contribution.
Five published resources spanning mathematics, agentic programming, energy policy, framework docs, and cloud infrastructure
Three entry points: learn (foundations), build (framework), understand (principles)
Five educational layers connected by progressive disclosure and the Amiga Principle
Design philosophy: proof before assertion, learning through building, humane flow
created_by_phase v1.34-327
last_verified 2026-03-06

tibsfox.com — Learning to Work Effectively with AI

This is an educational ecosystem. It contains a 923-page mathematics textbook, a detailed analysis of agentic programming, a 75-country energy efficiency study, a complete software framework with documentation, and a cloud infrastructure curriculum built using NASA systems engineering methodology. These resources were produced over 89 development milestones spanning 550+ phases, and they share a design philosophy that is worth making visible: proof before assertion, learning through building, and systems that support rather than shame.

The resources here grew from a single question: what happens when you take AI-assisted development seriously as a craft? Not as a novelty, not as a shortcut, but as a discipline with its own foundations, principles, tools, and community. The answer turned out to involve mathematics (because understanding precedes effective action), architecture (because good structure multiplies effort), and a commitment to showing work rather than just describing it. Every claim in this ecosystem is backed by something you can read, run, or verify.

What you will find here is not a sales pitch. It is a collection of things that were built because they needed to exist, organized so that the connections between them become clear. If you are here to learn, there is a path. If you are here to build, there is a framework. If you are here to understand how it all fits together, there are principles that explain why things were designed the way they were.

Where to Start

Three paths lead into this ecosystem depending on what brought you here. Each path is self-contained, but they connect. Following any one of them will eventually introduce the others.

"I want to learn." Start with the Foundations layer. The mathematical and philosophical groundwork here gives you the vocabulary and mental models that everything else builds on. You do not need a mathematics degree. The Space Between was written for autodidacts, and the eight-layer progression from unit circle to information theory was designed to be followed, not jumped into.

"I want to build." Start with the Framework layer. The GSD Skill Creator documentation gives you a working system for AI-assisted development: skills, agents, teams, and an orchestrator that coordinates them. The getting started guide takes you from installation to your first working skill in minutes. Build something first, then explore the principles when you want to understand why it works.

"I want to understand how this was made." Start with the Principles layer. The design decisions behind the tools and content are documented here: agentic programming, the Amiga Principle, progressive disclosure, and humane flow. These four ideas explain why the framework is structured the way it is and why the educational resources take the form they do.

The Five Layers

This ecosystem is organized in five layers, each building on the one beneath it. A reader can enter at any layer and find self-contained value, but the layers gain depth when read together. The progression from foundations to community traces the journey from understanding to action to contribution.

Layer 1: Foundations — Mathematical and Philosophical

The foundation layer provides the formal structures that ground everything above it. This is where the ecosystem earns its claim that proof precedes assertion.

The primary resource here is The Space Between, a 923-page mathematical textbook organized around the Complex Plane of Experience. It traces an eight-layer progression from the unit circle through Pythagorean relationships, trigonometry, vector calculus, set theory, category theory, information theory, and L-systems. Each layer introduces the mathematical concepts needed to understand the educational and computational tools built above it.

This layer is for autodidacts, mathematics learners, and anyone who wants to understand why the framework and applications work, not just how. The mathematics is not abstract decoration. The unit circle appears in the skill-creator's cache-aware ordering. Category theory informs the composition model for agent teams. Information theory underlies the token budget manager. These connections are made explicit in the gateway documents.

The foundation layer connects upward to Principles, where mathematical structures become design decisions. A reader who completes the eight-layer progression will recognize the formal patterns behind agentic programming and progressive disclosure.

Go deeper: Foundations

Layer 2: Principles — Agentic Programming and Design Philosophy

The principles layer translates mathematical foundations into design decisions. Four ideas govern how the tools are built and how the content communicates.

The primary resource is the Skills-and-Agents Report, a 10-section analysis of agentic programming covering everything from fundamental concepts through multi-agent architectures to the GSD orchestrator. The report documents 33 skills, 33 agents, and 12 teams, and it maps the territory between individual AI capabilities and coordinated system behavior.

Four design principles emerge from this analysis and shape the entire ecosystem. The Amiga Principle teaches that architectural leverage beats raw computational power, the way the Amiga's custom chips achieved extraordinary results through specialization rather than brute force. Progressive disclosure structures every document for three reading speeds: glance, scan, and read. Learning through building means the tools are designed to be used first and understood after, because doing teaches faster than studying. Humane flow means systems support rather than shame their users, and every tool in this ecosystem is built with that commitment.

This layer is for developers, architects, and anyone interested in the reasoning behind AI-assisted tooling. It connects downward to the mathematical structures that formalize these principles, and upward to the Framework where they are implemented as working software.

Go deeper: Principles

Layer 3: Framework — GSD Skill Creator Documentation

The framework layer is where principles become tools. This is the practical center of the ecosystem: documentation for the GSD Skill Creator, the system that makes AI-assisted development repeatable and improvable.

The primary resource is the GSD Skill Creator Documentation, covering getting started, core concepts, features, architecture, workflows, CLI reference, API reference, extensions, and troubleshooting. The canonical documentation source is this version-controlled docs/ directory. Documentation is synchronized to the tibsfox.com WordPress site via an MCP server integration, making updates available to the community for learning and reference.

The framework implements the principles from Layer 2 as concrete machinery. Skills are the unit of learned behavior. Agents compose skills into role-based actors. Teams coordinate agents into collaborative workflows. The GSD orchestrator manages the lifecycle from planning through execution to verification. The token budget manager, the 6-stage loading pipeline, the observation system, the bounded learning guardrails: each of these is a principle from Layer 2 made operational.

This layer is for developers and users who want to build with the framework. It connects downward to Principles for the reasoning behind design decisions, and upward to Applications for examples of the framework producing real educational content.

Go deeper: Framework

Layer 4: Applications — Proof Through Practice

The applications layer demonstrates the framework in action. These are not toy examples. They are published resources used by real people, and they serve as both proof that the approach works and as educational content in their own right.

The primary resources are the Global Power Efficiency Rankings, a 75-country energy analysis with AI tool integration prompts, career transition pathways, DIY projects, and Socratic learning patterns; and the OpenStack Cloud Curriculum, 72 pages of cloud infrastructure documentation including a sysadmin guide, operations manual, and 46 runbooks produced using NASA systems engineering methodology during the v1.33 mission. Additional educational packs covering electronics, BBS networking, the Amiga creative suite, and foundational knowledge across 35 subjects are documented in the educational packs index.

This layer is for the general public, career changers, system administrators, and learners across domains. It connects downward to the Framework that produced it and upward to the Community where contributors can build their own educational packs using the same templates and tools.

Go deeper: Applications

Layer 5: Community — Contributing and Sharing

The community layer is where the ecosystem becomes participatory. The tools and templates from the layers below are designed to be reusable, and this layer provides the pathways for contribution.

This layer is still emerging. The contributing guide documents how to participate in the project. The skill exchange envisions a shareware-style model where skills, agents, and educational packs can be shared and adapted. The code of conduct establishes standards for community interaction built on the humane flow principle: systems support, never shame.

The community layer connects downward to every other layer. Contributors can work at any level: improving mathematical content, refining design principles, extending the framework, building new educational applications, or improving the documentation itself. The templates extracted from exemplar content in Layer 4 make it possible to create new educational packs without starting from scratch.

Go deeper: Community

The Through-Line

The Commodore Amiga shipped in 1985 with three custom chips: Agnus for memory, Denise for graphics, and Paula for sound. While competing machines threw faster CPUs at every problem, the Amiga achieved extraordinary multimedia performance through architectural leverage. Each chip did one thing exceptionally well, and the system's power came from their coordination. Deluxe Paint did not explain bitplanes to its users. It let them paint, and the architecture became visible only to those curious enough to look beneath the surface.

This ecosystem follows the same principle. The GSD Skill Creator does not require anyone to understand category theory before creating a skill. The Power Efficiency Rankings do not announce that they were produced by wave-based parallel execution across five specialized agents. The tools work, and the architecture reveals itself to those who follow the thread downward through the layers. Mathematical foundations support design principles. Design principles shape the framework. The framework produces applications. Applications demonstrate that the approach works. And the improvement cycle — where skill-creator observes what works, captures patterns as skills, and feeds them into the next mission — ensures the system gets better each time it is used. That feedback loop is the heartbeat of everything here. It is what transforms a collection of documents into a living educational system.