Instagram story viewer> @agentic.james> Posts

James Goldbach

@agentic.james

43.3K

followers

124

following

Learn agentic AI with me👇

POSTS STORIES REELS TAGGED

Download All

Agents aren't models. Agents aren't harnesses. Agents aren't files and folders. They're all three! #aiagents #llms #agents #claudecode #chatgpt by @agentic.james

149

62

2 months ago

What really is an agentic coding loop? #claudecode #claude #aiagents #aiautomation #vibecoding by @agentic.james

141

63

3 months ago

Using any harness, all from your phone, with shared context and agent to agent messaging. #aiagents #claudecode #codex #aiautomation #ai by @agentic.james

124

10

2 months ago

How to build a software factory, follow one bug from report to production. The trick isn't more agents. It's checks good enough that the number of agents stops mattering. 1. Intake. Every bug and feature request goes to one tracker agent and gets a unique ID. 2. The brief. The coordinator promotes IDs by writing a brief for each: base commit, the feature test, and guardrails. No weaker assertions, bounded timeouts, no overfitting. 3. Fan out. Parallel sessions, each in its own sandbox or git worktree and branch, so they never collide. 4. Fail first. Every fix starts by reproducing the bug as a failing test, plus a new custom verification rule so it can't regress. 5. The gate. A gate agent with a fresh context window tries to break the fix, and adapts to each new change. 6. Use it like a human. Agents drive the app on phone and desktop with logs and screen recordings running. 7. Staging, then prod. One thumbs-up promotes staging to prod with auto-rollback armed, and anything weird in production becomes a new ticket with a failing test. No magic prompt needed. The output is good because of the custom verification. by @agentic.james

52

66

2 days ago

How to build a software factory: custom verification you actually trust, so you can scale to thousands of agents and PRs without reading every diff yourself.

The trick isn't more agents. It's checks good enough that the number of agents stops mattering.

1. Trigger and intake. A user bug or a new feature request lands with one tracker agent that owns the ledger. Every request gets a unique ID. Nothing gets an owner until you say go.
2. The brief. The coordinator writes every job down before any code exists: base commit, acceptance checks, the test that must fail first, and what the session is not allowed to do (weaken assertions, lengthen timeouts, deploy, push).
3. Fan out. Many sessions in parallel, each in its own git worktree. Claude Code and Codex take the heavy work, OpenCode the cheap high-volume jobs. Hardest work gets the strongest model, narrow work gets a fast one.
4. Fail first. Every fix starts with a test that fails on the base. Then remove your own guard and watch the tests go red, so you know they actually test something.
5. The gate. A different agent that wrote none of the code tries to break it. In one release it ran 9,371 unit tests and 167/169 remote browser cases, and caught 2 regressions both authors had passed.
6. Use it like a human. Agents click through the built app on phone and desktop with logs, screenshots and recordings running.
7. Staging, then prod. Every release builds on staging and soaks for 10 minutes. One thumbs-up promotes staging to prod with automatic rollback, and production gets checked every 10 minutes.

No magic prompt. The output is good because of the checks, not the prompts.

Comment FACTORY and I'll send you the full blueprint: all 7 stations, the 7 verification layers, the model-tier table, the toolbox, and what still breaks. by @agentic.james

126

301

3 days ago

Your Claude Code subagents are probably paying for the same context over and over.

Here's why. Claude Code caches the start of every request: system prompt, tools, CLAUDE.md, history. If the next call lands before the cache timer runs out, that whole prefix bills as a cache read, 5% of the normal input price on Opus and Sonnet 5.5. If it lands after, you pay to write it all again.

And the timer depends on where the work runs:
- Main session: 1 hour on a subscription, 5 minutes on an API key, usage credits or cloud billing
- Fresh subagents and forks: 5 minutes

So a subagent that waits on a long build or test run comes back to a cold cache and re-pays for everything.

The fix is one line in settings.json (Claude Code 2.1.242+):
"subagentPromptCacheTtl": "1h"
You can also set it per agent with experimental: cacheTtl: 1h in the agent file.

But it isn't free. A 1-hour write costs 2x input, a 5-minute write 1.25x. On a 100k-token Opus 5.5 prefix:
- 10 calls, 30 seconds apart: $0.68 on 5 min vs $0.98 on 1 hour. Fast loops, keep 5 min.
- 10 calls, 10 minutes apart: $5.00 vs $0.98. Long pauses, 1 hour cuts ~80%.

Match the timer to the gaps between calls, not to how long the task runs.

Two more things:
- No timer fixes a prefix that keeps changing. Put stable stuff first and changing stuff last. A timestamp near the top breaks the match every time.
- Don't guess, check. Compare cache_creation vs cache_read tokens. /usage only shows the main session, so subagents need checking separately.

Numbers are API list prices for the prefix only, checked Oct 11. Not a Pro/Max quota calculator.

Comment CACHE and I'll send you the full kit: the settings, a cost calculator, and the checklist to confirm it's working.

#claudecode #aiagents #anthropic #claude aiautomation by @agentic.james

69

76

4 days ago

ChatGPT can now answer with a live interface, and it starts rendering before GPT-6 finishes writing.

OpenAI's own description: a library of native, streamable components plus a compiler that processes the interface as the model generates it. That's all they've published about the internals.

Thesys reverse-engineered the rest from ChatGPT web:
1. The model writes Markdown + UI tags + JavaScript
2. The server recompiles it every few hundred ms and repairs bad parts
3. A locked-down sandboxed worker runs it
4. ChatGPT draws only its own components

Sliders update with zero model calls. Prices are bound by reference to the search result instead of retyped by the model. And when the catalog can't do something, the model writes a full app in its own sandbox.

Their own list of rough edges is the most useful part for builders: the model can't see what you changed, logic errors fail silently, and state resets on reload.

If you're building generative UI: a fixed component catalog, tool data bound by reference, and check the computed numbers yourself. A valid UI is not a correct one.

Comment GENUI and I'll send you the full breakdown with every source.

#chatgpt #generativeui #aiagents #openai by @agentic.james

81

53

5 days ago

i built a skill pack that teaches your coding agent how to build its own JEV decision layer.

it's for the small bounded stuff. classifying, routing, scoring, yes/no gates. the decisions you don't want eating a full model call every time.

the pack walks your agent through designing it, building it, testing it and tuning it for a real workflow.

want it? comment jev and I'll send the whole thing straight to you. by @agentic.james

365

937

21 days ago

Loop engineering is really verification engineering.

Your agent loop is only as good as the check at the end of it. Agents stop when the work looks done. Without a check they can actually run, you are the verification step.

The 7 pieces of a real verification step:
1. A verification skill built for YOUR app, not apps in general
2. A feature map: every feature with its states, interaction surfaces and passing criteria
3. User flow charts: how a real user moves through the app
4. Programmatic tools so the agent drives the app like a user
5. Proof: screenshots and screen recordings from every test
6. A stop gate: the loop only ends when the proof passes
7. Upkeep: update the skill every time the code grows

Comment VERIFICATION and I'll send you my favorite verification skills.

#claudecode #aiagents #agenticcoding #aicoding #softwaretesting by @agentic.james

67

48

7 days ago

I made 16 pieces of content for 4 platforms in one day, and I barely touched any of it.

It's one content workflow skill pack with 6 skills nested inside it. Research, script, repurpose, and publish all run as one flow, so a single idea turns into posts for TikTok, YouTube, X and Instagram.

The full skill pack and the tutorial are in my Skool community, link in bio. by @agentic.james

72

3

8 days ago

I think code mode MCPs are probably the best way to give agents access to tools. Like MCP and CLI had a baby. #mcp #aiautomation #claudecode #codex #aiagents by @agentic.james

128

11

a month ago

This has been a super nice upgrade to my ai setup now that I use many harnesses across a few machines. #claudecode #codex #aiagents #mcp #ai by @agentic.james

123

13

a month ago