conchaydan

“AI Innovation and Nature in Harmony: The Driving Force of a Sustainable New Civilization”

[ArcBlock @ArcBlock_io]

Why Decentralization, Blockchain, and Crypto Tokens Matter in the “After Software” Era — and Why ArcBlock’s Vision Is Clearer Than Ever https://t.co/JTuZt41guB

[ArcBlock @ArcBlock_io]

Help you understand ArcBlock's vision and the future of software better. https://t.co/Fo37nznuce

[ArcBlock @ArcBlock_io]

Our AI-era vision for ArcBlock, and yes, ABT:

AI makes it possible for independent people to build software together—contributing ideas, compute, components, sales, and distribution.

Crowd Building, build what should exist. Share in the value you create. https://t.co/52afIajY3R

[conchaydan @conchaydan_n]

When AI builds apps, developers are just like "contractors" who come and go, but the "house and data" must always be yours. Juggling multiple API keys and bills isn't the answer. That’s why ArcBlock created ARC—to give control back to users. 🏠🌐 #ArcBlock #AI #Web3

[ArcBlock @ArcBlock_io]

When agents become the main builders and operators of software, where does your digital life live?

That's why we build ARC! https://t.co/gpqyW7z8mD

[ArcBlock @ArcBlock_io]

Every week, the ArcBlock engineering team shares what we’re learning from AI-native development — real tips, workflows, experiments, and lessons from the trenches. https://t.co/zaj2zS9xMg

[ArcBlock @ArcBlock_io]

ARC builds a realm you own — a computing environment where any agent can work for you. https://t.co/mwreKbP45o

[ArcBlock @ArcBlock_io]

What and Why is ARC: Agentic Realm Computer?

Agents don't need a better sandbox. They need a computer of their own. https://t.co/xF9ahEViAm

[ArcBlock @ArcBlock_io]

https://t.co/3t673XWSRL

[Robert Mao @mave99a]

2017–2020: We believed the digital economy would need identity, ownership, and decentralized infrastructure.

2020–2025: DID, Blocklet, DID Spaces, and AFS gradually built that foundation.

2025–: Agents arrived.

For the first time, we have digital actors that can autonomously build, produce, operate, and transact in this economy.

The infrastructure came first.
Now the inhabitants are arriving.

[Robert Mao @mave99a]

Thinking about running a small cohort for AI builders on ARC:

The goal isn��t to teach you how to code.

It’s to help you go from idea → shipped product.

Here��s the catch:

You pay tuition. (In ABT or USD)
You build in public.
You actually ship.

If you finish, I’ll refund 100% of your tuition.

If your product turns out great, I’ll also reimburse your Claude/Codex subscription(up to $200/month).

Would anyone actually want this?

[Robert Mao @mave99a]

Many people in our community have said that ArcBlock doesn’t do enough marketing. In hindsight, I understand why they feel that way.

We spent years talking to developers, researchers, and builders around the world—but too many of those conversations never made it beyond the room. Too little of the thinking, discussions, and lessons were shared publicly.

That’s on us.

Going forward, we want to change that.

[ArcBlock @ArcBlock_io]

Software is changing fundamentally in the AI era. Building, running, and evolving AI-native applications requires a different computing model—not just a better application server.
ARC moves blockchain, DID, storage, agents, and execution into a unified foundation, making them first-class citizens rather than optional add-ons.
This isn't just a product upgrade.
It's a new computer model for the agentic era.

[Robert Mao @mave99a]

We're upgrading Blocklet Server to ARC (Agentic Realm Computer). Here's why:

[ArcBlock @ArcBlock_io]

https://t.co/spobkDb6t3

[ArcBlock @ArcBlock_io]

https://t.co/Bt7FgCSJGD

[ArcBlock @ArcBlock_io]

https://t.co/qHtlUy9vOA

[ArcBlock @ArcBlock_io]

https://t.co/36Gu9F3aCG

[Robert Mao @mave99a]

We’re going to start sharing much more of our journey in public.

Not just product releases, but the thinking behind them—the architecture decisions, experiments, lessons learned, failures, trade-offs, and discussions that shape our work.

With AI accelerating software development, the bottleneck is no longer writing code—it’s sharing knowledge and evolving ideas together.

We’ll also be revisiting years of internal discussions, carefully curating and refining them with AI before making them public. Of course, we’ll avoid confidential information and premature commitments.

Hopefully this helps our community understand where we’re going, participate earlier, and build together with us.

More blogs. More discussions. More transparency. Less hype.

[Robert Mao @mave99a]

We have open-sourced a pair of agent skills, design-review and build-phases. They work together, and they solve one problem: when AI takes on a reasonably complex task, the plan drifts.

Both grew out of IDD, and so did the problem, so that is where I will start.

A Problem That Grew Out of IDD

IDD says: state the intent clearly, then let the AI plan its own implementation. In practice this beats writing specs. But after using it for a while, something shows up. The AI keeps asking for details.

Asking is good. Every question it asks is reasonable, and usually it lands on something I genuinely had not thought through. So I answer them, one by one.

The trouble is in my answers.

When I answer, I tend to bring in things that are not strictly relevant. I think out loud. Background, worries, ideas I have not settled yet, all of it goes in. The AI has no way to tell which part I actually meant, so it treats the whole thing as input and keeps asking about the parts that were not the point. I answer again, and bring in new tangents.

So it becomes a loop that feeds itself. Noise gets read as signal, then expanded into more questions.

A few rounds in, the intent file has swelled. A clean three-layer structure is now a long document, every line correct, every line something I answered carefully, and together they have lost the point. It feels like explaining something in so much detail that the listener no longer knows what you want.

From there it drifts. It latches onto some detail and runs, the direction bends, and the worst part is that I cannot say where the bend started. Every step is a reasonable continuation of the one before. Reading that document back, I have trouble pointing at the paragraph where it went wrong.

There is some irony in this. One of IDD's own complaints about SDD was that specs swell and scatter across files. IDD then grew its own version of the same disease, through question and answer instead of through templates.

The Manual Version: Two Terminals and Copy Paste

My first instinct was that somebody needed to audit the intent and the plan, and say whether it had gone muddy, whether there were blind spots.

The part that mattered: that auditor could not be the same agent I had just spent an hour talking to. The drift came out of that conversation. The agent had been inside it too long to see the problem. Every line looked like something it had thought carefully about, because it was.

So I opened a second terminal, pasted the whole intent and plan into it, and gave it one sentence of instruction: read this, tell me where it is muddled, where the blind spots are, where it contradicts itself. Do not edit, just name the problems.

That part worked about as well as I expected. It could see things the first agent could not, and the reason is not complicated: that content was something the agent and I had worked out together, so it had no distance from it. Every line looked like something it had thought about, because it had.

What surprised me was something else.

Looking back over that trail of questions, I noticed that when the AI asked me something, it usually already had a view, and the view was decent. It was not stuck. It was waiting for me to sign off.

The absurd part is that a few times it asked something I could not answer right away, so I went to a different AI agent to work out my answer, then pasted that back in.

That is when it landed that the problem was not the audit step. It was earlier: it should not have been asking me that much in the first place.

The asking was what introduced the noise. It asks, I answer, my answer drags in tangents, it follows the tangents and asks again. If it already has a decent read on the situation, the sensible arrangement is to let it decide and fix, and put me at the end looking at the result.

That is the founding idea behind both skills: let the agent review and fix on its own, and stop pulling the human into the detail questions.

To be clear, that is not the same as not needing a human. Both skills keep an explicit escalation path. design-review stops and hands things back when something calls for an architectural decision, and it only fixes documentation consistency and test coverage on its own, never the direction. build-phases has a named set of hard-stop conditions and reports instead of pushing through them.

So what got moved is not the human's involvement, it is the level of it. Details go to the agent, direction stays with the human. Answering twenty boundary conditions a day turns into making one call occasionally, and that second kind of involvement is the part that actually needs a person.

The manual version usually settled in three or four rounds. The second round had noticeably fewer problems. By the third it was mostly wording. By then the plan was much clearer, and I could feel that it held up, not "looks complete" but "following this probably will not stall halfway."

The process was dumb, and tedious enough that I would not do it every time. Those two things together are the signal to hand something to a machine.

design-review: Automating the Audit

design-review does what I was doing by hand, minus the pasting.

Each round it spawns a brand-new agent to read your planning document. That agent returns a list of problems and a score, the findings get fixed, and the next round starts. By default it runs until 95 or for at most 5 rounds. The 5 comes from the manual days, when three or four rounds was usually where it converged.

Note that the fixing is done by an agent too, not by me. It does have a boundary though: it only fixes documentation consistency and test coverage, never the architectural direction. When the direction genuinely needs to change, it stops and hands that back.

One design detail here is the most interesting thing in the whole setup: every round's auditor is brand new, and it cannot see any earlier round's conversation.

All it sees are the files on disk.

Which leads to a consequence that sounds odd and is entirely reasonable: your fix has to be written to the file and committed, or the next auditor will never know it happened. You cannot tell it "we covered that last round." You cannot lean on setup buried in the context. If a change does not survive being read cold by a stranger, it did not happen.

The other rule is that the auditor can only read, never edit. Finding problems and fixing them are two jobs. Let one agent do both and by the next round it is grading its own homework, so the score climbs because "I wrote this" rather than because the plan got better.

It also decides first what kind of document you handed it (an implementation plan, an architecture design, a post-mortem) and judges it accordingly. Measuring a post-mortem with an implementation-plan ruler only produces meaningless notes.

build-phases: A Solid Plan Still Needs Watching

Once the plan holds up, the next problem is execution. AI runs ten phases in one go, something breaks in phase three, and you find out at the end.

build-phases walks the plan one phase at a time. Each finished phase has to clear three layers: the build and tests pass, the feature actually runs, and then someone tries to break it with bad input. Only after all three does the phase count as done, and then a brand-new agent reviews it before the next phase starts.

It also requires the system to be fully working at the end of every phase. No half-finished phases.

One more hard rule: verification output has to be the raw thing, not a summary. "Tests passed" is not accepted. That sounds fussy. What it blocks is the most common failure of all, an agent reporting that it finished when it did nothing.

How to Use It

These are agent skills, not tied to one particular agent. Claude Code and Codex both run them.

Install:

npx add-skill arcblock/agentloop
Two commands:

/agentloop:design-review # review the plan until it holds up
↓
/agentloop:build-phases # build it phase by phase, verifying each
build-phases checks whether the plan has been reviewed, and sends you back to design-review if it has not. That order is enforced, because staging construction on a plan that still drifts only moves the problem later.
Both skills live in ArcBlock/agent-skills. Each SKILL.md is the whole implementation, so you can just read it.
When Not to Use It

Do not use this for small, clear changes. Fixing a bug, editing a string, adding a field: let the AI do it and run the tests. Spinning up a review loop plus phased execution is overkill there, and it will make you wait.

What it suits is the kind of work you cannot fully describe yourself, that will not finish in one sitting, and that tends to wander. The test is simple. If what worries you is "am I going to get halfway and find out the direction was wrong," use it.

This Is One Kind of Loop Engineering

The practice has a name now: loop engineering. The Pragmatic Engineer published a survey of it in July 2026 1, which quotes a definition from Addy Osmani that I think is the sharpest one available:

Loop engineering is replacing yourself as the person who prompts the agent.

Replace the person who keeps pushing the agent with a mechanism.

The starting point is a practical limit: a context window will not hold a whole large task. So instead of pushing through one ever-longer session, you cut the work into rounds. At the end of each round you check whether the goal was met, and if it was not, you open a fresh round with a clean context, carrying the previous round's output forward as the new starting point. The idea traces back to Geoffrey Huntley's Ralph Wiggum technique, and Matt Pocock's "Ship working code while you sleep" is what put it in front of a lot more people.
By now you have probably seen it: "open a fresh round with a clean context" is exactly what design-review does every round. We are not adjacent to this concept. What we built is one of them.

And Addy Osmani's sentence is close to a description of the manual stage above. Back then the person who kept pushing the agent was me, and my job was switching windows and pasting. What design-review and build-phases do, in the end, is take me out of that seat.

One thing does differ, which is how we got here. We did not see the loop engineering framing and go looking for somewhere to apply it. We worked backward from a specific defect in IDD: intent swells, plans drift, and something that was never in the conversation has to look at it. We ended up in the same place from a different direction.

When a concept can be reached from more than one starting point, that usually means it is right.

Closing

What design-review and build-phases add up to is this: have a plan picked apart by an AI that was not in the room, then build it step by step, and have each step picked apart again.

There is nothing clever in here. What does the work is still the dumb part, a fresh pair of eyes that no context has gotten to yet. All we did was hand the part of that loop I used to carry over to two commands.

IDD put it as "code review can be delegated to AI, intent review needs a human." After a year and change of using it, I would push that one step further: the polishing of the intent can go to an agent too. What the human holds onto is the direction, and the last judgment, whether this is the thing we wanted.

The difference is in what the human gets asked. It used to be twenty details. Now it is one question about whether to change course.

GitHub: https://t.co/Nhu3j5Ei8q

[ArcBlock @ArcBlock_io]

Excited to share that ArcBlock CEO will deliver a keynote at the 1st Harness4GenUI Workshop @ ASE 2026.

See you in Munich! 🚀
https://t.co/6FaXpg6U70