Every coding agent gets a plan before it spends a token. Ordewell breaks one goal into ordered tasks
Joined August 2026
- Tweets188
- Following397
- Followers62
- Likes186
Everyone draws the swarm. Almost nobody draws the order.
One goal becomes a graph of tasks. Edges are dependencies, so independent tasks run at once while dependent ones wait their turn. Every node carries its own harness and model, picked per task, visible before anything runs.
Parallelism without giving up control. That is the whole pitch.
github.com/ordewell/ordewell
A 'plan' that isn't showable isn't a plan. If the agent won't hand you an ordered, editable task list before it executes, it's guessing with your repo. Plan-as-artifact is the fix.
ordewell retweeted
Anthropic senior engineer just dropped a free 1-hour course on building production-grade AI agent harnesses with Claude Code:
0% → 00:19 - understand how the Claude Code harness actually works
25% → 14:20 - use CLAUDE.md & Plan Mode for long-horizon agents
50% → 23:38 - turn repeated workflows into reusable skills
75% → 44:01 - build agents and subagents with Claude
100% → 59:34 - agent teams, feedback loops & the Agent SDK
This 1-hour course is worth more than most $500 agent engineering courses
Watch it today
Then read the guide below and build a harness that lets your agents plan, verify, and recover on their own
ordewell retweeted
I was working on a new project for a client.
I estimated 8 hours for a new booking system. It took 18 hours.
I had built this kind of workflow before. I had Claude Code the whole way, but I still was off by my estimate by more than double.
If I had quoted off my estimate I would have charged $800 and worked ten hours for free.
ordewell retweeted
The winner of an Anthropic hackathon open sourced his entire Claude Code setup - and this is absolute f*cking gold
68 subagents, 286 skills, 94 commands, MIT license
ECC swaps a lone Claude Code assistant for a whole engineering department
a blueprint comes before any build, a failing test comes before any fix, and every change gets a second look from a context that never saw it written
• who does what
> planning - hand it a single sentence, get back a plan you sign off before a line of code
> review - a fresh-context read of your diff, with its own reviewer for each language
> build repair - a dedicated fixer per toolchain, PyTorch and CUDA included
> security - an OWASP sweep, plus a scanner hunting injection holes in your agent config
> architecture - catches design mistakes while they're still cheap, before they turn into migrations
> domain work - database queries, ML pipelines, e2e tests, docs
the security duo is the piece most people never set up
an external OWASP audit costs four figures and a week of waiting
this one wraps up on your branch by lunchtime
• what the skills cover
> testing - tdd-workflow moves you from red to green, eval-harness runs above it
> language packs - Python, Go, Rust, C++, Django, Laravel, Spring Boot, Next.js
> context - search-first checks the docs before writing, iterative-retrieval stops your whole repo flooding the window
> shipping - Docker, CI/CD, health checks, rollbacks, migrations
> beyond code - writing in your voice, market research, pitch decks
fork it, trim it, and have your own version running by tomorrow
begin with a single plan and a single rules pack
turning on all 286 skills at once is the quickest way to make it worse
whoever wires this in over a weekend spends the next quarter reviewing work instead of typing it
ordewell retweeted
PR descriptions are written at the end, by someone who wants to be done. They describe the change, rarely the reasoning, and almost never the alternative that lost.
That was acceptable when a human carried the reasoning between sessions. With Claude Code or Codex, the author of the change disappears when the terminal closes. The next session starts from the diff and guesses, and a capable model guesses confidently.
In Frame we moved the writeup to a different moment. After every task, not after the merge, the agent appends to outcome.md: what shipped, what diverged from the plan, what is left. The most recent one in our repo reads "Reversed T04's inherited reuse rule after use showed it wrong." Nobody would put that sentence in a PR description. It is precisely the sentence the next agent needs.
Plans say intent. Code says reality. The outcome is the part in between, and it is the part that decays fastest if nobody records it at the time. No context window, however large, recovers a reason that was never written down.
Frame is open source and works with Claude Code and Codex, with whatever model you already pay for. I would like to hear how other teams capture the moment an agent changes its mind:
The most underrated dev-tool feature in the agent era: a plan you can read and edit before anything runs. No surprise at step 4. Editability plus agent orchestration.
ordewell retweeted
13.4% of ai agent skills in open marketplaces have critical security vulnerabilities.
a new open source registry scans every skill with a security tool before it's published, works with claude code, cursor, github copilot, and a dozen other agents.
install a skill like a plugin instead of re-explaining the same workflow to your agent on every new project.
ordewell retweeted
Anthropic just cut Claude Code limits 17% overnight.
The 50% boost ended at midnight, replaced by a permanent 25% over baseline. But that number only lives in a social post. Anthropic docs just say limits returned to standard levels.
Run /usage before you plan your week.
ordewell retweeted
6 things I always add to new .NET projects 👇
1. Coding conventions
2. Static code analysis
3. Observability - OpenTelemetry
4. Agents (AGENTS .MD) - Claude Code or Codex
5. Docker-compose / Aspire - orchestration
6. CI/CD pipeline for build & test (bare minimum)
I built a free Clean Architecture template that has all of this.
Get it here (it's free): milanjovanovic.tech/template…
ordewell retweeted
Most multi-agent failures begin at the handoff.
Words moved. Authority, state, evidence, and acceptance did not.
I mapped the five planes that turn delegation into engineering, and the design behind ORRERY.
ordewell retweeted
My ~40 minute tutorial about building a feature-rich CODING AGENT HARNESS from scratch, no frameworks
Tools, bash, file reads, writes, patch updates, cache-aware prompting, compaction, context mgmt, late injections, TODOs, plans, permissions, sandboxes, subagents... 👇🏼
ordewell retweeted
An Anthropic engineer put out a 1-hour breakdown of how agentic systems actually run in production:
00:19 - what Claude Code does under the hood
14:20 - long-horizon agents, CLAUDE.md and Plan mode
23:38 - skill design patterns for agents
44:01 - building agents and subagents
59:34 - self-improving loops and graphs
The last section is the one most people skip and the one that matters: an agent that logs its own failures and rewrites its own instructions stops needing you in the loop.
Full write-up on loops and graphs below.
Before your next repo task, ask: can I name every task the agent is about to run, in order, before it spends a token? If not, you're not planning — you're gambling. A read-only planner makes the plan the artifact: ordewell.ai
ordewell retweeted
This week was the first week I've actually pushed AI enough where I significantly benefited from Codex resets.
A lot of orchestration agent swarm sessions and long running task observation.
I'm not sure if I'm happy with the results tbh, I think my approach before of being the orchestrator was much more token efficient and produced better quality output.
Still experimenting though, it's all about a good feedback loop, if the model can properly verify results it's output is at least 10x better.
ordewell retweeted
One of the questions I ask myself frequently:
Where am I being a subagent for Codex, and what do I need to build to get out of the way?
Building software to get yourself out of the loop is an extremely high-leverage activity.
ordewell retweeted
If you don't know, you can use DeepSeek V4.1 Flash as a subagent inside a GPT-6 Astra Codex workflow.
That means Astra can plan the work and delegate implementation to Flash.
This can cut your AI agent costs massively.
You just need to set it up once.
Here's how:
Step 1: Install codex-router
curl -fsSL raw.githubusercontent.com/du…
| sh -s -- --target codex --guided --with-tray
Step 2: Add your DeepSeek/Opencode API key
Enable:
deepseek/deepseek-v4-flash
as a subagent model.
Keep GPT-6 Astra as your root model.
Do NOT make Flash the default root model.
Step 3: Tell Astra how to delegate
Use this rule:
"You are the orchestrator.
Use Astra for planning, architecture, security-sensitive decisions and final review.
For implementation, coding, debugging, research, writing, data processing and routine work, explicitly delegate bounded subtasks to deepseek/deepseek-v4-flash.
After Flash finishes, inspect the result yourself before accepting it."
Step 4: Verify it
Run a small implementation task.
Check router activity.
You should see:
Astra → delegates → DeepSeek Flash → result → Astra reviews
That's it.
$20 ChatGPT Plus.
~$30 DeepSeek credits.
A 24/7 AI workforce for around $50/month.
Full guide below 👇
DeepSeek just launched V4.1 Flash.
98% of GPT-6 Astra’s score at 1.4% of the cost.
With GPT-6 Astra + DeepSeek V4.1 Flash, you can build an AI workforce that works 24/7 for around $50/month.
Full setup:
ordewell retweeted
This is the document I wish I had before I configured my first AI agent.
Researchers scanned nearly three thousand real repositories to see which of the eight ways to configure a coding agent people actually use. Here is the order I would go in now.
1. Start with a context file and nothing else.
Build and test commands, code conventions, what the agent must not touch. Write it for someone joining the project on Monday, not for a model.
Most working setups never go past this file. The ones that do added the rest months later, after the context file was already good.
2. Name it AGENTS.md, not CLAUDE.md.
Every major tool reads it. Claude Code still does not, so keep a two-line CLAUDE.md that points at AGENTS.md and maintain one file instead of two. Repos that started with CLAUDE.md are adding AGENTS.md and pointing the old one at it, so you might as well start there.
3. Only create a skill after you have typed the same instructions three times.
And when you do, give it a script. Almost every skill in the wild is plain markdown with nothing executable in it, which means it is doing nothing a context file could not already do.
If your skill is just instructions, it belongs in the context file. If it runs something, it belongs in a skill.
4. Add a subagent only when a job needs its own context, not its own name.
Review, research, anything that would otherwise flood your main thread. Not "I want a specialist for each role". Most repos that use subagents define one or two, and that is the right number.
5. Skip hooks and MCP until something forces you there.
Hooks when instructions get ignored and you need something that can actually refuse. MCP when the agent needs a system that has no file in your repo.
The advanced features are sitting almost completely unused. That is the opportunity, not the checklist.
