🚧 feezify 2.0 — beta coming soon. The AI-native rewrite of my old training SaaS. Want it in early access? Join the waitlist →
A training copilot, gone AI-native. A skill + a portable markdown core. Zero infra.
feezify reads your day: your objective form (training load) crossed with how you actually feel and what your own journal remembers — then tells you, in plain words, whether today is green, amber, or red, and why. It does not prescribe workouts. You decide; it helps you read yourself more clearly.
🇫🇷 Version française : /fr/README.md · 📖 Full docs (install & use):
docs/ · The method, in the open:
method.md
feezify was a hosted SaaS — a Node/Express/Mongo app with accounts, a database, a server, a frontend, deploys. Most of it was plumbing. The actual value was a small thing buried inside: a way of crossing objective training load with subjective readiness, and a judgment about when how-you-feel should override what-the-numbers-say.
When AI agents arrived, ~90% of that app became dead weight. The method didn't.
feezify is rebuilt AI-native: it installs on your own AI as a skill, reads a folder of markdown you own, and runs entirely on your machine — no server, no account, no telemetry.
The design is the AI-native remap of the classic web app, tier by tier. The browser was the last interface shift — once it won, we rebuilt every application engine for it. The LLM/chatbot is the next one. But you don't plug the old app into it: you rebuild the engine one layer down, as an agent, and the database becomes a memory:
| Classic web app | The tier | AI-native app |
|---|---|---|
| Browser / frontend | the interface | the LLM / the chatbot |
| Server / backend | the application engine | the agent — hexagonal core (the method) + adapters to third-party apps |
| Database | the persistence | a second-brain memory — your log + an agent wiki that compresses it |
You don't open my app; you install my agent on your own AI. (That migration is the subject of the companion article.)
The v1 ships one skill: the read of the day.
Hexagonal — ports & adapters — so the method stays pure and every provider is replaceable:
- Domain (
src/domain) — entities, the load math (TSS → CTL/ATL/TSB as proper exponential averages), the readiness score, and the crossing rule. No I/O, no provider names. This is the wedge, and it's fully unit-tested. - Ports (
src/ports) —DataSource(activities in),Repository(your markdown core),LectureDuJour(the read out). - Adapters (
src/adapters) —strava-mcpandstrava-rest(two ways into Strava — via an MCP host or the public REST API; either way, relative-effort is flagged incompatible and load is recomputed from raw, mapping shared instrava-shared),markdown-repo(your core), and two driving adapters over the same engine:claude-skillandopenclaw-skill(SKILL.mdeach — they turn the deterministic skeleton into the day's read). Adding a provider or a surface is near-free: same bin, same domain, different adapter.
The numbers and the light are deterministic; the AI reads your narrative journal across days for the patterns a spreadsheet can't see, and writes the read.
Two memories. Your journal/ is your daily log (you write it). The copilot also keeps
its own memory of you in memory/ — a compiled, interlinked model it reads first and updates
after each session (Karpathy's LLM Wiki pattern: stop re-deriving, start compiling). Over
time it stops re-reading months of journal and reads what it already learned about you, every
claim traced back to a journal day.
Load gives TSB (form); your journal gives readiness. The subjective gates the
objective — injury/illness is always red, low readiness is never green, fresh legs never
override a body saying no. Full version: method.md.
It's open on purpose: the method is the point, not a secret.
Two ways in — full details in onboarding.md:
A. No terminal (3 steps) — for athletes on Claude:
- Connect the official Strava connector in Claude (Connectors → Strava → OAuth).
- Download
feezify-skill-<version>.zipfrom the latest release and upload it in Claude → Settings → Skills. - Ask "how am I today?" — the copilot creates your core and sets you up in conversation.
B. Developer path — clone and build:
pnpm install && pnpm build
cp -r core-template ~/my-feezify-core # your private core (profil, objectifs, journal, memory)
cp .env.example .env # then add your Strava tokens (see onboarding.md)
node dist/lecture.js ~/my-feezify-core 2026-06-29Then point your AI at the skill — it ships as a Claude skill
(src/adapters/claude-skill/SKILL.md), an OpenClaw skill
(src/adapters/openclaw-skill/SKILL.md), and the self-contained zip surface
(src/adapters/claude-skill-zip/SKILL.md) — same engine, three envelopes.
Adapter tokens go only in
.env(git-ignored) — never in any other file. Seeonboarding.mdandAGENTS.md → Secrets. The no-terminal path never touches tokens at all: Strava's official connector handles auth via OAuth.
- Tell it who you are: fill
core-template/user.mdin your core (name, main sport, level, profile, what you're chasing) — read as context, never a diagnosis. - Choose your connectors: in
core-template/config.yml, a connector (e.g.strava) stays off until you set ittrue— the copilot only exchanges your data with a third party once you've explicitly opted in (consent). - Add a journal entry: copy
templates/journal-day.mdtojournal/YYYY-MM-DD.mdand fill it in — markers (sleep, fatigue, motivation, mood, stress, appetite, thirst) plus a few honest sentences (how the legs felt, any niggle, what's going on in life). - Ask your AI how you are today. It reads its memory (
memory/) and your journal, runs the deterministic read, and tells you green / amber / red and why — it never prescribes.
Built by Nicolas Jouanno — see author.md (who I am, my training articles,
and how to support the project on Tipeee).
This is an early build — beta, feedback welcome. Open an issue with what reads true and what doesn't. The next steps are evaluation harnesses for the skill and a world-model layer for current state.
Apache-2.0. The moat is the method, the voice, and distribution — not the code.