feed-the-machine 1.4.0 → 1.4.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +82 -180
- package/package.json +1 -1
package/README.md
CHANGED
|
@@ -1,158 +1,56 @@
|
|
|
1
1
|
# Feed The Machine
|
|
2
2
|
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
FTM is a cognitive architecture for Claude Code — not a prompt library, not a wrapper, not scaffolding that dies on the next model drop. It's a persistent intelligence layer that learns how *you* work and gets better every time you use it. The OODA (Observe, Orient, Decide, Act) reasoning loop, the blackboard memory, the multi-model deliberation, the event mesh — these are design patterns that become *more* valuable as models improve, not less.
|
|
6
|
-
|
|
7
|
-
Drop in anything. A support ticket, a feature spec, a bug report, a half-formed idea, a meeting transcript, a "figure this out." The machine reads everything, proposes a plan, waits for your approval, then executes end-to-end. Every successful execution becomes a playbook. Every playbook makes the next similar task faster.
|
|
8
|
-
|
|
9
|
-
The machine hungers. You feed it. It takes care of you.
|
|
10
|
-
|
|
11
|
-
---
|
|
12
|
-
|
|
13
|
-
## Plain English
|
|
3
|
+
**Make Claude Code actually remember things and do entire jobs, not just answer questions.**
|
|
14
4
|
|
|
15
5
|
You know how every time you start a new chat with an AI, it has no idea who you are, what you're working on, or what you tried last time? You end up repeating yourself constantly. And when you ask it to do something complex, you have to hold its hand through every single step.
|
|
16
6
|
|
|
17
7
|
FTM fixes that.
|
|
18
8
|
|
|
19
|
-
It's a brain upgrade for Claude Code (Anthropic's AI coding tool). You install it once, and from that point on:
|
|
20
|
-
|
|
21
|
-
- **It remembers.** Not just within one conversation — across all of them. It builds a memory of your projects, your preferences, what worked before, and what didn't. The more you use it, the less you have to explain.
|
|
22
|
-
|
|
23
|
-
- **It plans before it acts.** You throw a task at it — could be a bug, a feature request, a vague idea, whatever — and instead of immediately doing something dumb, it reads your context, makes a plan, and shows you the plan first. You approve it, tweak it, or tell it to rethink. Then it goes.
|
|
24
|
-
|
|
25
|
-
- **It does the whole thing, not just one step.** Most AI tools help you write a function or answer a question. FTM coordinates entire workflows — it can read a support ticket, look up the customer's history, draft a response, update the ticket, and notify your team. All from one input.
|
|
26
|
-
|
|
27
|
-
- **It gets a second opinion.** For hard decisions, it doesn't just trust one AI. It asks Claude, GPT, and Gemini independently, then picks the answer where at least two agree. Like calling three contractors instead of trusting the first quote.
|
|
28
|
-
|
|
29
|
-
- **It gets better over time.** Every task it completes becomes a playbook. See the same type of bug three times? It already knows the pattern. Similar support ticket? It remembers what worked last time. It's not just a tool — it's a tool that sharpens itself.
|
|
30
|
-
|
|
31
|
-
Think of it like this: regular AI is a blank whiteboard every time you walk into the room. FTM is an assistant who was in yesterday's meeting, read the doc you shared last week, and already has a draft ready when you walk in.
|
|
32
|
-
|
|
33
9
|
---
|
|
34
10
|
|
|
35
|
-
##
|
|
36
|
-
|
|
37
|
-
Most AI tooling is disposable by design. You write prompts, the model gets better, your prompts become unnecessary. That's the scaffolding thesis — and it's true for most of what people are building.
|
|
38
|
-
|
|
39
|
-
FTM is built on the opposite bet: **the orchestration layer survives model drops.** Three things in this system are structurally hard for any single model provider to absorb:
|
|
40
|
-
|
|
41
|
-
**Persistent memory that compounds.** Claude's native memory is conversation-scoped. FTM's blackboard is a three-tier knowledge store — context, experiences, patterns — that persists across every session. By your twentieth task, it knows your stack, your team's conventions, the quirks of your external services, and what kinds of plans you tend to push back on. It's not remembering facts. It's building judgment.
|
|
42
|
-
|
|
43
|
-
**Multi-model deliberation.** FTM's council sends hard decisions to Claude, Codex, and Gemini as equal peers, then loops through rounds of debate until 2-of-3 agree. No model provider will ever natively ship "ask our competitors for a second opinion." That's permanently outside their incentive structure.
|
|
11
|
+
## What It Actually Does
|
|
44
12
|
|
|
45
|
-
|
|
13
|
+
You install it once. From that point on, Claude Code gets three superpowers:
|
|
46
14
|
|
|
47
|
-
|
|
15
|
+
**It remembers across conversations.** Not just within one chat — across all of them. It builds up knowledge about your projects, your preferences, what worked before, and what didn't. The more you use it, the less you have to explain.
|
|
48
16
|
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
## The Loop
|
|
52
|
-
|
|
53
|
-
Every task, every time:
|
|
54
|
-
|
|
55
|
-
```
|
|
56
|
-
FEED --> PLAN --> APPROVE --> EXECUTE --> LEARN
|
|
57
|
-
^ |
|
|
58
|
-
+------------- (next task) --------------+
|
|
59
|
-
```
|
|
17
|
+
**It plans before it acts.** Throw a task at it — a bug, a feature request, a vague idea, whatever. Instead of immediately doing something dumb, it reads your context, makes a plan, and shows you the plan first. You approve it, tweak it, or tell it to rethink. Then it goes.
|
|
60
18
|
|
|
61
|
-
**
|
|
19
|
+
**It does the whole thing, not just one step.** Most AI tools help you write a function or answer a question. FTM coordinates entire workflows — it can read a ticket, look up history, write the code, run the tests, update the docs, and validate everything. All from one input.
|
|
62
20
|
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
**APPROVE** — You review the plan. Modify it, ask questions, or just say "go."
|
|
66
|
-
|
|
67
|
-
**EXECUTE** — Parallel agent teams work through the plan. Each wave completes, validates, and checks in before the next begins. Browser automation, git ops, test runs, API calls — all coordinated.
|
|
68
|
-
|
|
69
|
-
**LEARN** — Every outcome writes back to the blackboard: what worked, what failed, what pattern to remember. Next time you bring a similar task, the machine already knows the shape of it.
|
|
70
|
-
|
|
71
|
-
---
|
|
72
|
-
|
|
73
|
-
## Architecture
|
|
74
|
-
|
|
75
|
-
```mermaid
|
|
76
|
-
graph TD
|
|
77
|
-
User["User Input\n(ticket / spec / idea / error)"] --> Mind
|
|
78
|
-
|
|
79
|
-
subgraph Core["FTM Core"]
|
|
80
|
-
Mind["ftm-mind\n(OODA Cognitive Loop)"]
|
|
81
|
-
BB["Blackboard\ncontext.json\nexperiences/\npatterns.json"]
|
|
82
|
-
Mesh["Event Mesh\n18 typed events"]
|
|
83
|
-
end
|
|
84
|
-
|
|
85
|
-
Mind <-->|read / write| BB
|
|
86
|
-
Mind -->|route| Mesh
|
|
87
|
-
|
|
88
|
-
subgraph Skills["Skill Layer"]
|
|
89
|
-
Storm["ftm-brainstorm\nSocratic ideation\n+ parallel research"]
|
|
90
|
-
Debug["ftm-debug\nMulti-vector\ndebugging war room"]
|
|
91
|
-
Exec["ftm-executor\nAutonomous plan\nexecution"]
|
|
92
|
-
Council["ftm-council\nClaude + Codex + Gemini\n2-of-3 consensus"]
|
|
93
|
-
Browse["ftm-browse\nHeadless browser\n+ accessibility inspection"]
|
|
94
|
-
Git["ftm-git\nSecret scanning\n+ credential gate"]
|
|
95
|
-
Audit["ftm-audit\nKnip + adversarial\nLLM wiring check"]
|
|
96
|
-
end
|
|
97
|
-
|
|
98
|
-
Mesh --> Storm
|
|
99
|
-
Mesh --> Debug
|
|
100
|
-
Mesh --> Exec
|
|
101
|
-
Mesh --> Council
|
|
102
|
-
Mesh --> Browse
|
|
103
|
-
Mesh --> Git
|
|
104
|
-
Mesh --> Audit
|
|
105
|
-
|
|
106
|
-
subgraph Integrations["External Integrations (via MCP)"]
|
|
107
|
-
Jira["Jira"]
|
|
108
|
-
FS["Freshservice"]
|
|
109
|
-
Slack["Slack"]
|
|
110
|
-
Gmail["Gmail"]
|
|
111
|
-
end
|
|
112
|
-
|
|
113
|
-
Browse --> Jira
|
|
114
|
-
Browse --> FS
|
|
115
|
-
Mind --> Slack
|
|
116
|
-
Mind --> Gmail
|
|
117
|
-
|
|
118
|
-
Exec -->|code_committed| Intent["ftm-intent\nINTENT.md layer"]
|
|
119
|
-
Exec -->|code_committed| Diagram["ftm-diagram\nARCHITECTURE.mmd"]
|
|
120
|
-
Exec -->|task_completed| Retro["ftm-retro\nmicro-reflection"]
|
|
121
|
-
Exec -->|wave boundary| Gate["ftm-codex-gate\nadversarial validation"]
|
|
122
|
-
Gate --> Exec
|
|
123
|
-
```
|
|
21
|
+
Think of it like this: regular AI is a blank whiteboard every time you walk into the room. FTM is an assistant who was in yesterday's meeting, read the doc you shared last week, and already has a draft ready when you walk in.
|
|
124
22
|
|
|
125
23
|
---
|
|
126
24
|
|
|
127
|
-
##
|
|
128
|
-
|
|
129
|
-
Install:
|
|
25
|
+
## Install
|
|
130
26
|
|
|
131
27
|
```bash
|
|
132
28
|
npx feed-the-machine@latest
|
|
133
29
|
```
|
|
134
30
|
|
|
135
|
-
|
|
31
|
+
That's it. Takes 30 seconds. Works with any existing Claude Code setup.
|
|
136
32
|
|
|
137
|
-
|
|
33
|
+
---
|
|
34
|
+
|
|
35
|
+
## Try It Right Now
|
|
138
36
|
|
|
139
|
-
**
|
|
37
|
+
**Just talk to it:**
|
|
140
38
|
```
|
|
141
39
|
/ftm
|
|
142
40
|
```
|
|
143
|
-
Paste anything — a
|
|
41
|
+
Paste anything — a ticket, an error, a feature idea, or just describe what you need. FTM figures out what to do, shows you a plan, and waits for your OK before doing anything.
|
|
144
42
|
|
|
145
|
-
**
|
|
43
|
+
**Think something through:**
|
|
146
44
|
```
|
|
147
45
|
/ftm-brainstorm
|
|
148
46
|
```
|
|
149
|
-
Describe something you're trying to figure out. It
|
|
47
|
+
Describe something you're trying to figure out. It researches the web and GitHub in parallel, challenges your thinking, and surfaces options you hadn't considered.
|
|
150
48
|
|
|
151
|
-
**
|
|
49
|
+
**Kill a bug:**
|
|
152
50
|
```
|
|
153
51
|
/ftm-debug
|
|
154
52
|
```
|
|
155
|
-
Paste an error
|
|
53
|
+
Paste an error or describe weird behavior. It attacks the problem from multiple angles at once — way faster than stepping through it manually.
|
|
156
54
|
|
|
157
55
|
---
|
|
158
56
|
|
|
@@ -160,106 +58,110 @@ Paste an error message, stack trace, or just describe unexpected behavior. It op
|
|
|
160
58
|
|
|
161
59
|
### Triaging a support ticket
|
|
162
60
|
|
|
163
|
-
**
|
|
61
|
+
**Before** — Open the ticket. Read it. Check Slack for context. Look up the customer. Figure out who handles it. Draft a response. Copy-paste between four tabs. 30 minutes of context-gathering before any real work.
|
|
164
62
|
|
|
165
|
-
**
|
|
63
|
+
**After** — Paste the ticket URL. FTM reads it, pulls context, checks for similar past issues, makes a plan, and waits. You say "go." Done in 3 minutes.
|
|
166
64
|
|
|
167
65
|
---
|
|
168
66
|
|
|
169
|
-
### Building a feature
|
|
67
|
+
### Building a feature
|
|
170
68
|
|
|
171
|
-
**
|
|
69
|
+
**Before** — Open five files, switch between spec and codebase, write the code, realize the patterns are different from what you remembered, check another file, write tests separately, forget the docs, ship it and wonder why things are failing.
|
|
172
70
|
|
|
173
|
-
**
|
|
71
|
+
**After** — Paste the spec. FTM already knows your codebase patterns, proposes a plan: code, tests, docs, validation. Parallel agents handle the work. Documentation updates automatically. Everything stays consistent.
|
|
174
72
|
|
|
175
73
|
---
|
|
176
74
|
|
|
177
|
-
### Configuring an admin
|
|
75
|
+
### Configuring something in an admin panel
|
|
178
76
|
|
|
179
|
-
**
|
|
77
|
+
**Before** — 45 minutes. Find the vendor docs. Navigate the panel manually. Cross-reference settings. Hope you didn't miss a field.
|
|
180
78
|
|
|
181
|
-
**
|
|
79
|
+
**After** — 5 minutes. Paste the ticket. FTM reads the docs, opens a browser, navigates the panel, fills the fields, screenshots the result. You review and approve each step.
|
|
182
80
|
|
|
183
81
|
---
|
|
184
82
|
|
|
185
|
-
##
|
|
186
|
-
|
|
187
|
-
| Skill | What It Does |
|
|
188
|
-
|-------|-------------|
|
|
189
|
-
| **ftm-mind** | Observe-Orient-Decide-Act cognitive loop — the universal entry point; reads context, sizes tasks, routes everything |
|
|
190
|
-
| **ftm-executor** | Autonomous plan execution with dynamically assembled agent teams and wave-by-wave progress |
|
|
191
|
-
| **ftm-debug** | Multi-vector debugging war room — parallel hypothesis testing, static + runtime + dependency analysis |
|
|
192
|
-
| **ftm-brainstorm** | Socratic ideation with parallel web and GitHub research agents; challenges assumptions, surfaces options |
|
|
193
|
-
| **ftm-audit** | Wiring verification — knip static analysis plus adversarial LLM audit of skill connections |
|
|
194
|
-
| **ftm-council** | Multi-model deliberation — Claude, Codex, and Gemini debate to 2-of-3 consensus on hard decisions |
|
|
195
|
-
| **ftm-codex-gate** | Adversarial Codex validation at executor wave boundaries before proceeding |
|
|
196
|
-
| **ftm-retro** | Post-execution retrospectives and continuous micro-reflections after every task |
|
|
197
|
-
| **ftm-intent** | INTENT.md documentation layer — function-level contracts, auto-updated on every commit |
|
|
198
|
-
| **ftm-diagram** | ARCHITECTURE.mmd mermaid diagrams — auto-regenerated after commits |
|
|
199
|
-
| **ftm-browse** | Headless browser — screenshots, accessibility tree inspection, form automation, visual verification |
|
|
200
|
-
| **ftm-git** | Secret scanning and credential safety gate for all git operations |
|
|
201
|
-
| **ftm-pause** | Save current session state to the blackboard mid-task |
|
|
202
|
-
| **ftm-resume** | Restore a paused session and continue exactly where you left off |
|
|
203
|
-
| **ftm-upgrade** | Self-upgrade from GitHub releases |
|
|
204
|
-
| **ftm-config** | Configure model profiles and execution preferences |
|
|
205
|
-
| **ftm** | Bare invocation — equivalent to `/ftm-mind` with plain-language input |
|
|
83
|
+
## How It Gets Smarter
|
|
206
84
|
|
|
207
|
-
|
|
85
|
+
FTM keeps a memory (called the "blackboard") that persists across every conversation:
|
|
208
86
|
|
|
209
|
-
|
|
87
|
+
| Layer | What It Remembers | Example |
|
|
88
|
+
|-------|------------------|---------|
|
|
89
|
+
| **Context** | What you're working on right now, recent decisions | "Currently building auth system, chose JWT over sessions" |
|
|
90
|
+
| **Experiences** | What happened on past tasks — what worked, what didn't | "Last time we hit this error, the fix was in the middleware config" |
|
|
91
|
+
| **Patterns** | Lessons that keep coming up — gets promoted after 3+ confirmations | "This team's API always needs CORS headers added manually" |
|
|
210
92
|
|
|
211
|
-
|
|
93
|
+
**Cold start is fine.** The first few conversations build up context fast. By your 10th-20th session, FTM knows your stack, your conventions, and what kinds of plans you tend to push back on.
|
|
212
94
|
|
|
213
|
-
|
|
214
|
-
|------|--------------|----------------|
|
|
215
|
-
| `context.json` | Current task, recent decisions, your stated preferences | Every single request |
|
|
216
|
-
| `experiences/*.json` | Per-task learnings — one file per completed task, tagged by type | Orient phase, filtered by similarity to current task |
|
|
217
|
-
| `patterns.json` | Insights promoted after 3+ confirming experiences — durable heuristics | Orient phase, matched to the current situation |
|
|
95
|
+
Every task makes it smarter. Fix a bug? It remembers the root cause. Ship a feature? It remembers the patterns. See the same issue three times? It already knows what to do.
|
|
218
96
|
|
|
219
|
-
|
|
97
|
+
---
|
|
220
98
|
|
|
221
|
-
|
|
99
|
+
## What's Included
|
|
100
|
+
|
|
101
|
+
FTM comes with 20+ specialized skills. You don't need to memorize them — just use `/ftm` and it picks the right ones automatically. But here's what's under the hood:
|
|
102
|
+
|
|
103
|
+
| Skill | Plain English |
|
|
104
|
+
|-------|--------------|
|
|
105
|
+
| **ftm-mind** | The brain. Reads your input, pulls memory, picks the right approach, makes a plan |
|
|
106
|
+
| **ftm-executor** | The hands. Takes the plan and actually does the work with parallel agents |
|
|
107
|
+
| **ftm-debug** | Bug detective. Attacks problems from multiple angles simultaneously |
|
|
108
|
+
| **ftm-brainstorm** | Thinking partner. Researches, challenges assumptions, surfaces options |
|
|
109
|
+
| **ftm-council** | Second opinions. Asks Claude, GPT, and Gemini, then goes with the majority |
|
|
110
|
+
| **ftm-browse** | Web automation. Opens browsers, fills forms, takes screenshots |
|
|
111
|
+
| **ftm-git** | Safety net. Scans for leaked passwords/keys before you push code |
|
|
112
|
+
| **ftm-audit** | Quality check. Makes sure all the code is actually connected and working |
|
|
113
|
+
| **ftm-map** | Codebase intelligence. Knows which files matter most and what breaks if you change something |
|
|
114
|
+
| **ftm-intent** | Living docs. Keeps documentation updated automatically when code changes |
|
|
115
|
+
| **ftm-diagram** | Architecture diagrams. Auto-generated and auto-updated |
|
|
116
|
+
| **ftm-retro** | Self-improvement. Reviews its own work and learns from it |
|
|
117
|
+
| **ftm-pause / resume** | Save and restore. Pick up exactly where you left off |
|
|
118
|
+
| **ftm-config** | Settings. Choose which AI models to use for what |
|
|
119
|
+
| **ftm-upgrade** | Self-update. Stay current with one command |
|
|
222
120
|
|
|
223
121
|
---
|
|
224
122
|
|
|
225
|
-
##
|
|
123
|
+
## The Secret Sauce
|
|
226
124
|
|
|
227
|
-
|
|
125
|
+
Three things make FTM different from "just using Claude Code":
|
|
228
126
|
|
|
229
|
-
**
|
|
127
|
+
**1. Memory that compounds.** Claude normally forgets everything between conversations. FTM's memory persists forever and gets smarter over time. By your 20th task, it knows things about your project that would take a new developer weeks to learn.
|
|
230
128
|
|
|
231
|
-
**
|
|
129
|
+
**2. Second opinions from multiple AIs.** For hard decisions, FTM asks Claude, GPT, and Gemini independently, then goes with the answer where at least two agree. Like calling three contractors instead of trusting the first quote.
|
|
232
130
|
|
|
233
|
-
|
|
234
|
-
git clone https://github.com/kkudumu/feed-the-machine.git ~/feed-the-machine
|
|
235
|
-
cd ~/feed-the-machine
|
|
236
|
-
./install.sh
|
|
237
|
-
```
|
|
131
|
+
**3. Workflow orchestration.** FTM doesn't just answer questions — it coordinates multi-step workflows with parallel agents, automated testing, and validation gates. It's closer to having a junior dev on your team than having a chatbot.
|
|
238
132
|
|
|
239
|
-
|
|
133
|
+
---
|
|
240
134
|
|
|
241
|
-
|
|
135
|
+
## Advanced Setup
|
|
242
136
|
|
|
243
|
-
**Model profiles** — edit `~/.claude/ftm-config.yml
|
|
137
|
+
**Model profiles** — Control which AI models handle what (edit `~/.claude/ftm-config.yml`):
|
|
244
138
|
|
|
245
139
|
```yaml
|
|
246
140
|
profile: balanced # quality | balanced | budget
|
|
247
141
|
|
|
248
142
|
profiles:
|
|
249
143
|
balanced:
|
|
250
|
-
planning: opus #
|
|
251
|
-
execution: sonnet #
|
|
252
|
-
review: sonnet #
|
|
144
|
+
planning: opus # the deep thinker
|
|
145
|
+
execution: sonnet # the fast worker
|
|
146
|
+
review: sonnet # the checker
|
|
253
147
|
```
|
|
254
148
|
|
|
255
|
-
**Optional
|
|
149
|
+
**Optional extras** for the full experience:
|
|
150
|
+
|
|
151
|
+
- [Codex CLI](https://github.com/openai/codex) — Powers the second-opinion council and code validation
|
|
152
|
+
- [Gemini CLI](https://github.com/google/gemini-cli) — Third voice in the council
|
|
153
|
+
- Playwright MCP server (`npx @playwright/mcp@latest`) — Powers browser automation
|
|
256
154
|
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
155
|
+
Everything else runs on Claude Code alone.
|
|
156
|
+
|
|
157
|
+
**Dev install** (if you want to contribute):
|
|
158
|
+
|
|
159
|
+
```bash
|
|
160
|
+
git clone https://github.com/kkudumu/feed-the-machine.git ~/feed-the-machine
|
|
161
|
+
cd ~/feed-the-machine && ./install.sh
|
|
162
|
+
```
|
|
261
163
|
|
|
262
|
-
|
|
164
|
+
**Uninstall:** `./uninstall.sh` (removes skills, keeps your memory data)
|
|
263
165
|
|
|
264
166
|
---
|
|
265
167
|
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "feed-the-machine",
|
|
3
|
-
"version": "1.4.
|
|
3
|
+
"version": "1.4.1",
|
|
4
4
|
"description": "A unified intelligence layer for Claude Code — 22 skills with OODA-based reasoning, persistent memory, multi-model deliberation, and optional operator cockpit inbox",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"author": "kkudumu",
|