If you only skim one thing this month: the center of gravity has moved from single‑tool prompts to shared, cross‑agent skills and harnesses. The GitHub “continue‑dev” and “coding‑agent” topic feeds are full of plug‑and‑play skills, MCP servers, and lightweight CLIs that run equally well under Claude Code, Codex, Cursor, Copilot, and the rest — and they’re getting real traction.[1][2]
What actually shipped in the wild
The most interesting releases weren’t just new models — they were skills and harnesses that make any agent smarter out of the box.
- HarmonyOS skill packs that spit out config files for 11+ tools (Claude Code, Cursor, Copilot, Codex, Gemini CLI, Windsurf, and more) so agents can work ArkTS/ArkUI like a native. Updated July 25, 2026.[1]
- Self‑hosting recipes at scale: “open‑forge” claims 2,200+ verified deploy recipes (provisioning, DNS, TLS, hardening) your agent can run — designed for Claude Code, Codex, Cursor, Aider, OpenClaw, Hermes. Updated June 3, 2026.[1]
- Vision MCP servers that any agent can hit for image/video understanding — designed for Claude, Cursor, OpenCode, local LLMs, Gemini, etc. Updated August 14, 2026.[1]
- Local‑first chat: a VS Code extension that speaks to LM Studio or Ollama so your “copilot” runs on your GPU. Updated July 17, 2026.[1]
In the broader coding‑agent stream, several projects set the tone:
- “planning‑with‑files” (26.2k★) formalizes persistent, crash‑proof plans and per‑turn re‑injection to fight context rot; it’s installable from npm, the Claude Code marketplace, or npx skills and supports 60+ agents.[2]
- jcode (17.5k★) bills itself as “the most RAM efficient harness,” a pragmatic choice for long‑running or CI agents.[2]
- grok‑cli (3.4k★) and command‑code (3.7k★) keep the terminal‑first crowd happy with lightweight, scriptable agent CLIs.[2]
- tutti (3.3k★) is a shared, local‑first agent workspace for multi‑agent collaboration with MCP support.[2]
- If you’re building your own: deep‑dive notes on Claude Code’s agent loop and context engineering are now open for inspection.[2]
And in the “subagents” track, spec‑driven development (SDD) harnesses like cc‑sdd (3.6k★) and catalogs like buildwithclaude continue to make approved specs the source of truth for autonomous work across Claude Code, Codex, Cursor, Copilot, Windsurf, OpenCode, Gemini CLI, and Antigravity.[3]
Planning is the new memory
Long‑running agents drift unless you anchor them. That’s why file‑based planning is exploding: persistent Markdown plans that survive /clear, re‑inject each turn, and gate completions deterministically. That’s “planning‑with‑files,” and it’s quickly becoming table stakes across 60+ agents.[2]
Here’s a minimal plan skeleton I actually check into repos:
# plan/session-0001.md
## Goal
Ship a minimal image-diff service that compares screenshots and returns a per-pixel heatmap.
## Scope
- Inputs: two PNGs
- Output: PNG heatmap + JSON summary
- Non-goals: auth, persistence, UI polish
## Steps
- [ ] Enumerate I/O and CLI flags
- [ ] Write reference tests for 3 cases (identical, small diff, big diff)
- [ ] Implement core diff
- [ ] Add threshold and ignore regions
## Artifacts
- src/diff.ts, bin/diff
- tests/*.spec.ts
- docs/README.md (usage + examples)
## Risks
- Performance on large images
- False positives due to compression
And a Makefile guard that forces a plan to exist before you let an agent run unattended:
plan-guard:
@test -f plan/session-0001.md || { \
echo "Create plan/session-0001.md before running the agent."; \
exit 1; \
}
agent: plan-guard
# invoke your preferred agent CLI here, pointed at the repo root
# e.g., `grok run` or `command-code run` with your config
Use whatever harness you like — jcode for low‑RAM CI runs, tutti for a shared local workspace, or a terminal CLI (grok‑cli / command‑code) when you want pipes and logs — but anchor it in files so the plan survives restarts and context rotation.[2]
Claude Code: small fixes, real safety wins
August’s Claude Code updates aren’t flashy, but they matter in daily use:
- Spend‑limit warnings now surface the actual cap, the reset time, and the operator’s message (when you’re behind a gateway that supports it).
- The
claude agentscommand now shows a workspace trust prompt for untrusted directories, aligning with the mainclaudebehavior. - Background agents pulse “N done” in the footer when they finish, and session transcripts record reasoning effort per assistant message.
- Subagent permission inheritance is simplified (the Task tool’s mode param is deprecated), and headless/SDK sessions can honor a mid‑turn
set_modelcontrol so the next round‑trip uses the new model.
All of that ships in August’s notes and related fixes.[4]
What the trust prompt looks like in practice:
$ claude agents
Untrusted workspace: /Users/geneva/dev/experimental
Trust this folder? [y/N]:
My rule: keep experiments untrusted, and only trust repos once you’ve added a planning file and a minimal guardrail (tests, or a dry‑run flag). The new spend‑limit warning is also a quiet gift for teams — it turns a surprise bill into an explicit, time‑boxed cap you can talk about in standup.[4]
Prices and picks, honestly
On price, one big change: as of June 1, 2026, GitHub Copilot moved to usage‑based AI Credits (1 credit = $0.01). There’s still a free tier (2,000 completions and 50 agent requests/month), Pro at $10/month, and business tiers — but heavy agent use is now a variable bill, which moves the budget conversation from “per seat” to “how much autonomy did we run this sprint?”[5]
On performance, the current leaderboard has Claude Code paired with Claude Opus 5 at the top (65.5) by a sliver over OpenAI Codex with GPT‑5.6 Sol (65.1) — and the Claude pairing was the faster of the two in every published round in that index. Still, “best” depends on your workflow: Cursor remains the best AI‑native IDE if you never leave your editor; Copilot is the default for a GitHub‑centric team on a budget. The referenced page actually chooses and prices, not just listicles you’ve already scrolled past.[5]
A minimal cross‑agent workflow you can ship this week
- Create a plan folder and commit a session file (see the Markdown skeleton above); gate unattended runs behind a simple Makefile target. This buys you crash‑proof memory and deterministic gates even if you swap CLIs (grok‑cli, command‑code, jcode, tutti).[2]
- Add one shared skill: pair your agent with a vision MCP server so it can diff screenshots, label UI states, or validate designs. Most of the popular vision servers advertise compatibility with Claude, Cursor, OpenCode, Gemini, and local LLMs — wire it up once, then reuse it across agents.[1]
- If you deploy: pick a verified recipe from a self‑hosting catalog and let your agent run it under supervision. The point isn’t “no‑ops”; it’s reproducible provisioning and hardening with a human in the loop.[1]
- Tighten guardrails in Claude Code: keep experiments untrusted until the plan lands, and watch the spend‑limit warnings if your org fronts a gateway.[4]
Key takeaways
- Cross‑agent skills (planning, vision, deploy recipes) beat one‑off prompts; wire them once, reuse everywhere.[1][2]
- File‑based plans are becoming the default way to anchor long‑running work across 60+ agents.[2]
- Claude Code’s August updates make day‑to‑day safer: trust prompts, clearer spend caps, simpler subagent permissions.[4]
- Pricing changed: Copilot’s AI Credits make heavy agent use a budget variable; choose tools by workflow, not hype.[5]
References
- continue-dev · GitHub Topics — https://github.com/topics/continue-dev
- coding-agent · GitHub Topics — https://github.com/topics/coding-agent
- subagents · GitHub Topics · GitHub — https://github.com/topics/subagents
- Claude Code Updates by Anthropic – August 2026 — https://releasebot.io/updates/anthropic/claude-code
- Best Programming AI 2026: Claude Code, Cursor or Copilot? — https://www.orcarouter.ai/blog/best-programming-ai
Leave a Reply