What's the Arkos MVP?

I’ve been writing about a new way to code — a system where software is designed visually, structured through typed interfaces, and implemented through contextual test-driven development.

It’s a big idea. But every big idea needs a small start.

This post is about the minimum viable product for Arkos. Not the final vision, not the polished platform — but the first loop. The smallest version of Arkos that proves the concept, delivers value, and gets the flywheel turning.

Why Start Small?

Because Arkos isn’t just a diagramming tool. It’s not just an editor. It’s not just infrastructure-as-code with a UI.

It’s a new interface for building software — one that makes structure visible, types enforceable, and context navigable.

If I try to build everything at once, I’ll fail. The goal of the MVP is to:

Prove that visual design can drive real code

Show that typed interfaces reduce friction

Demonstrate that testing can be contextual and integrated

It doesn’t have to be perfect. It just has to work once — end to end.

The First Loop

The MVP is one complete cycle:

Draw a system

Define contracts

Write a test

Write the code to pass the test

See the test pass and the system validate

That’s the smallest loop worth building. Not because it’s minimal in effort, but because it’s complete in intent.

It proves:

The diagram is real

The type system works

The tests are connected

The behavior can be implemented

The whole thing is composable and expandable

Once this works, I can reuse the same interface to add new blueprints, swap modules, add a deploy step, or simulate flows. But it starts here.

What the MVP Includes

Let me get specific.

✅ A Visual Editor

A canvas to draw basic diagrams using a small set of UML-style shapes:

Rectangles for modules

Diamonds for logic

Arrows for flow

✅ Typed Connections

When you connect two modules, you specify an input/output type — likely JSON-schema or something Zod-like to start.

Connections are only valid if types align.

✅ One Executable Blueprint

A single kind of module that runs logic.
For example: a MapInputToOutput box that takes an input, runs a function, and returns a result.

✅ A Code Editor

Clicking into a box opens a code editor (like Monaco or CodeMirror) where you write test-first logic.

Tests live inside the module, use the defined type, and validate behavior.

✅ Test Feedback

Tests can be run, and the results visually update the diagram:

✅ green check if it passes

❌ red indicator if it fails

That’s it. One module, one type system, one visual feedback loop.

What It Doesn’t Include (Yet)

No auth.
No multi-user editing.
No deploy pipeline.
No database.
No UI toolkit.
No sidebar search, palettes, plugins, or integrations.

All of that can wait.

Why This MVP Is Enough

This MVP isn’t just a toy — it’s a seed.

Once it exists, I can:

Show how structure emerges visually

Build a library of testable blueprints

Prove the UI can drive code, not just represent it

Let others play with the concept and give feedback

It unlocks iteration. Which is exactly what Arkos is designed for.

Closing Thoughts

Arkos is ambitious. But ambition is just scale.
Direction matters more.

This MVP is the first working loop — a visual-to-code cycle that starts small, but proves something big: that code can be shaped, understood, and tested in context.

From there, everything else is just turning the flywheel.