Shivam Sinha

Co-founder & CTO | Qumis - Shoshin of Thoughts, Ideas and Perspectives.

[Shivam Sinha @OGSinha]

https://t.co/Dl2XfDpeDf

[Aakash Gupta @aakashgupta]

If you’ve been procrastinating on learning loops, read this.

[Rahul @sairahul1]

Anthropic and OpenAI are both telling engineers to write loops.

Not prompts.
Not agents.
Loops.

That is not a coincidence.

When the two most important AI labs on the planet independently converge on the same pattern — that is a signal worth paying attention to.

Most engineers are still thinking in terms of single calls.

Input → model → output.

The engineers winning in 2026 think in cycles.

Output becomes input. The model evaluates its own work. The loop runs until the result is right.

This is the complete breakdown of what loops are, why they matter, and how to build them ↓

[Paweł Huryn @PawelHuryn]

Six patterns for building dynamic workflows and loops identified by Anthropic:

1. Classify-and-act: one agent decides the type, the script routes it. Example: bug vs feature vs noise.

2. Fan-out-and-synthesize: one agent per piece, merged in code. Examples: market research, competitor teardown.

3. Adversarial verification: a separate agent checks the output against a rubric. Example: fact-checking a PRD against the sources.

4. Generate-and-filter: many candidates, deduped, the survivors kept. Examples: naming, positioning, ideation.

5. Tournament (compare): agents attempt the task different ways, judges compare until one wins. Example: product strategy.

6. Loop-until-done: spawn until a stop condition. Example: implement, document, and test a feature in one shot.

[Dan Shipper 📧 @danshipper]

this is good

[Vojta Holik @vojta_holik]

knowledge has a shape

[Thariq @trq212]

Workflows are the biggest upgrade to Claude Code’s capabilities since skills and subagents.

I dove deep into it with @sidbid to figure out best practices, examples and more.  I’m particularly excited about the non-technical tasks it enables for Claude Code.

[Drew Breunig @dbreunig]

This pattern is going to be everywhere.

Once you understand your task(s), a small model will do.

[Prajwal Tomar @PrajwalTomar_]

I still don't think people understand what just happened with Codex.

This new secret tool can now take you from rough idea to fully designed, agency-tier UI in under an hour.

Most builders are skipping the brainstorming step and getting AI-default designs that look like every other vibe-coded app.

This 4-step workflow gets you professional designs on the first try:

(full breakdown in the article)

[Niels Rogge @NielsRogge]

Impressive release by StepFun, explore it at https://t.co/T2BNnPHiRM

[Ben Lang @benln]

Pulled the fastest-growing startups by hiring velocity over the past 90 days:

[Gabriel @gabriell_lab]

Since Opus 4.8 is out and more and more designers are getting into Design Engineering, I thought I’d share some of the interaction patterns I use most often:

Use proximity, not just hover. When the cursor gets close, nearby elements can subtly scale and darken based on distance.

It makes interfaces feel more responsive, less binary, and way more alive

onpointermove = e =>
document.querySelectorAll(".dock>*").forEach(el => {
const r = el.getBoundingClientRect();
const t = Math.max(0, 1 - Math.abs(e.clientX - r.x - r.width/2) / 120);
el. style.scale = 1 + t * .5;
});

[Michael Livs @micLivs]

introducing pi-dynamic-workflows

This is probably going to be a bigger token burner than pi-goal, BUT, dynamic workflows is the first implementation of subagents that i don't hate, mainly because it's "code mode" for subagents. agent writes a js-based workflow DSL into a dedicated tool, engine parses the workflow code and runs it.

the dsl implements some primitives for the agent (agent(), parallel(), pipeline(), phase() and log()) to keep it as simple as possible.

now available in @badlogicgames pi!

pi install npm:pi-dynamic-workflows

[ericosiu @ericosiu]

Every company is missing the same layer:

A company brain.

Right now, the memory of the business is scattered across calls, docs, Slack threads, dashboards, SOPs, and people's heads.

That's the part people miss when they talk about a company brain.

The value isn't a giant folder of company knowledge. Every company already has that.

The real advantage is the intelligence layer that sits between all that context and the work your team needs done.

This is the layer every AI-native company will need:

[Mike Piccolo @mfpiccolo]

https://t.co/GK1ojr8Opb

[McKinsey & Company @McKinsey]

Agentic orchestration layers allow AI agents, enterprise systems, and data connections to work together across functions.

As cognitive bottlenecks shrink, that allows decision-making to speed up, coordination to improve and new operating models to form. https://t.co/0to4HC26cu

[Joe Schmidt IV @joeschmidtiv]

https://t.co/i7teOUTWgZ

[Lance Martin @RLanceMartin]

a number of useful tips + tricks for Opus 4.8:

1/ you can now update the system prompt mid-conversation w/o breaking the prompt cache.

previously, you had to add <system-reminder> tags to user messages (see @trq212's post).

https://t.co/wX5lYjBXvJ

https://t.co/hyd4vmxWXv

[dex @dexhorthy]

someone hit me up about the new "claude dynamic workflows" feature, claiming "see, multi-agent works"

But really, the launch of this feature proves the exact point that I made back in June of 2025, along with @walden_yan, @tobi, @karpathy, and many others:

Deterministic workflows orchestrating small agent loops beats non-deterministic multi-agent or "agent soup" systems every dang time

everything is context engineering

[Omar Khattab @lateinteraction]

the interactive buttons are so instructive! and frankly just satisfying also

[Paweł Huryn @PawelHuryn]

Tested Claude Code's new dynamic workflows. 8 agents in 24.5s. 253k tokens.

The launch post frames it as a large fleet of coordinated subagents. That part isn't new. The SDK has had parallel calls for years.

The new part is where the orchestrator runs. It's JavaScript, not a Claude turn. The routing logic is code, so it doesn't spend model tokens.

Each subagent keeps its own context, tools, and intermediate calls. The parent thread gets the return value. Not 8 transcripts. Not 50k tokens of grep noise. One object.

A 20-agent audit can spend 600k tokens across isolated agents and return a 2k-token synthesis. Before this, "comprehensive review" meant filling the context you still needed for the fix.

Scripts persist at .claude/workflows/<name>.js. Invoke by name with args. They're cron-schedulable and compose one level deep. It's like a function library.

I've been treating subagents as context isolation, not delegation. Dynamic workflows move that from one agent to a fleet.

Not fan-out. The mess stays out of the parent thread.