Docs

What does this training word mean?

What names does the product own, and what freezes them?

What does the product look like?

What training cycle does this product serve?

What words and metadata describe the app on the App Store?

What is this product for?

How does the app talk to the athlete?

How this repository works binds everybody, and it lives in docs/. Each evergreen page under docs/ and tools/ registers as a skill under .agents/skills/.

AGENTS.md holds the rules that bind every agent that works here, and the import below loads it. This file holds what only Claude Code can obey: a hook, a tool, and the line that ends a background session.

Which parts deliver on their own, and how does each boundary stay compatible?

What earns a place on a page of assumptions, and what does an entry carry?

Which jobs does CI run on a pull request?

How does a Bazel target stay small and cacheable?

Which rules does the code follow here, in every language?

How does a name in the code state what it names, in every language?

How is a test of the Python of tools/ written, and how is it measured?

Which rules does the Python of tools/ follow?

Which role does a type of a Swift app take, and how does its name state it?

How is a test of the Swift of this repository written, and how is it measured?

Which rules does the Swift of this repository follow?

What makes a test worth keeping here, whichever language it is written in?

What makes a commit, and how is its message written?

Which rules tie two build tools together, and what must a change pass before it lands?

Which parts, images and links to other issues does a filed issue carry?

How is a GitHub Actions workflow written here: its name, its runner, its caches, its secrets and its steps?

How do you repair a broken fetch, add a module, and measure a cache hit?

How do you test a change to a workflow, free a run that waits on a removed runner, and read the log of a job that still runs?

Which labels does an issue carry, and what does each one say?

Which stage of review does a page bind?

How do you assign a taken issue, read its images, close it or let it go?

What is the system built with?

How does this repository place, run and measure its tests?

How does an agent rank an open issue, and how does a person correct the rank?

How does an author plan a change and carry it to a pull request?

Which kinds of pages exist, what is each one for, and where does a fact live?

Which person holds each role that the other pages name?

Which folder holds which pages in this repository?

How does this repository keep up with the libraries, languages and platforms that it depends on?

How does this repository write a sentence?

An iOS and watchOS app that models strength training and running as one budget of training load, spent toward a race date.

What are the pieces of the system, and how does each one depend on the others?

What does lb docs graph draw, and why does no commit carry the result?

Which layer holds a rule, and which suite tests it?

What does the log of this app hold for the person who reads it?

Where do the records live, and what carries them between two devices?

Which beliefs of the app remain unverified?

What does the app know of her running, and what finish time does it state?

What SDK builds this, and what OS runs it?

Which pages of Apple's Human Interface Guidelines bind a screen, and what does this app decide inside them?

How does one session become a number?

How does the app plan the days ahead of the athlete?

How does her readiness cut the run of the day?

How does the coach replay against open data, and how do a KPI and a study read it?

Which run does the coach pick today, and how long is it?

Who signs a build, and why not Release on a laptop?

How does this app control the typeface of its text?

How does a UI test of the app reach one state, check a screen, and wait for it?

What carries a version, what does it mean, and what carries none?

How does a commit on main become a release candidate on TestFlight, and what records it?

How does a release candidate become a release branch, and what can the branch take?

How does a release branch become a version on the App Store?

What does a submission need that no build writes?

What carries a TestFlight build and the feedback that comes back?

What does Apple run for this repository, and how do we read it back?

What does the app give Xcode Cloud, just and the tools?

How does the app reach a simulator, an iPhone and an Apple Watch?

What does the workflow graph read from GitHub Actions workflows, and what does it draw?

What is on loadbudget.com and dev.loadbudget.com, and how does each one deploy?

Which hook does each agent run, and why does a cell stay empty?

Which beliefs of the tools and the machines remain unverified?

How do the auto mode rules of this repository reach the classifier of Claude Code?

How does a change meet the complexity targets, and which file or page splits first?

What is a recipe for, where does it live, and what must it not do?

How does this repository adopt the review product?

What does each hook check, and how does it run?

What does the client send to App Store Connect, and what does it read back from Xcode Cloud?

What does the delivery of an Apple app take from its caller, and what does it write?

How does a person read the stability and the timing of the tests of an app?

Which beliefs of the app tools remain unverified?

Which commands of lb act on the app, and what do they read from the checkout?

What does a report run of the app tests state about the reference exports?

Which infrastructure interfaces do installed tools share?

Which rule pages does each specialist of a review read?

How do provider adapters isolate and complete a review?

Which review beliefs remain unverified?

How does a review run inside: its locks, its stages, its server, its files and its clocks?

What does this word of the review mean?

What does the review product accept, expose, and refuse?

Which prose checks and formatting commands can other products use?

What is a rule page, which product owns one, and what does the lint refuse?

What does the complexity ratchet measure, and what does it refuse?

What does the watch print about a pull request, and what ends the watch?

Which beliefs of the fingerprint remain unverified?

What does the fingerprint cover, and how does it reach the cache key of Bazel?

What does the pytest runner take, and what does the coverage check refuse?

What do the stage branches of a repository hold, and what does the product do with them?

What does an agent session start do to a repository, and what does it answer?

Which recipe and module descriptions does the lint refuse, and how does it exit?

What does the command write to a pull request, and what makes it refuse?

Which beliefs about the build machines remain unverified?

How do the Linux machines keep roles apart from machines in one Ansible project?

How does the VM lb-agents run its accounts, its sessions of Remote Control and the tools that every account shares?

How does a Linux NativeLink worker get its image, and what can an action on it reach?

How does a Mac run the NativeLink worker, and how does it run each action?

How do Caddy and the NativeLink scheduler admit a call and send an action to a worker?

How does a runner of GitHub Actions on a host of GARM run a job, and what keeps one job apart from the next?

Where does each build machine read the release of each tool?

What does this word of the infrastructure mean?

How does the operator give a new account on a host its logins, so that its Remote Control bridge serves?

Which alert reaches the operator, and what does the operator do about it?

How does the operator install lb-hetzner02, and how does a merged change reach it?

How does the operator join a Mac to the build as a worker?

How does the operator install Ubuntu on lb-minisforum?

Where does each secret come from, and how does the operator replace it?

What does each machine that builds this repository give a person, an agent identity and a build client, and what must each one give?

What does a cloud session at claude.ai/code need, and what does it do another way?

How does a session hand work to a session on another machine, and how does it read the answer?

What readies a laptop to run this repository?

How does a session on a laptop run a command as root on a machine?

What do the pin commands read, print, edit and report, and what makes them refuse?

Which beliefs of the feedback Worker remain unverified?

How does the Worker sign in, how is its code laid out, and how does a person measure and change it?

How does the operator deploy the Worker, and set up what it needs once?

What does the Worker accept, what does it start on GitHub, and what does it answer?

What does the check wait for, and what status does it write?

Which beliefs of the signer remain unverified?

How does the signer build a credential that R2 accepts?

What does the signer give each caller of its socket, and what does it refuse?

Which beliefs of the audit remain unverified?

What does the command build, what does it run again, and what does it report?

How does Bazel build the command, and how does serve make each VM?

What does the command give a host of GitHub Actions runners, and what does it refuse?