u/VirusStrict7031

When a large project is going on display. What is the best strategy to do so? I don't think large notes is the best way to go. Nobody will read thousands of lines.

Many questions come to my mind about how the split of how to post personal thinking and architectual proof across linkedin, X and git repo.

How would you do to catch the attention of both technical people and a wider audience? When it comes down to it this is about how to self promote and marketing strategies. This becomes the portfolio that need to be understood in different layers of technical ability for the readers.

What would you do?

I’ve been hitting a limit working with AI on a large system.

---

Early on, “mostly correct” is fine.

You fix things as you go.

But at some point that stops working.

When you’re doing convergence work,

95% correct isn’t usable.

Because the remaining 5% compounds.

With dependencies between surfaces,

one small mistake early → everything downstream will be build on a broken path.

So the requirement changes:

It’s not “good output”

It’s “provably correct or I can’t proceed”

At that point, I needed to regain control.

Better prompts and roles weren’t enough.

I was already separating concerns into roles

and running controlled tasks.

That worked… until the system complexity grew.

The real constraint became context.

As files got denser and scope demanded more detail:

• context windows became a bottleneck

• constraints started conflicting across tasks

• different missions required different rules

At the same time I had:

• the actual database

• canonical files

• a mirror of the system in Obsidian

Multiple representations of the same system.

Trying to manage all of that in one flow didn’t work.

What I ended up doing:

Keep one core role.

Switch execution using explicit protocols (each with its own constraints and scope)

So instead of one “smart role”, I now have:

• one executor

• multiple execution modes (protocols)

• files as the source of truth

Each protocol runs with a defined scope and constraint set.

It only loads what it needs

and enforces constraints for that specific mission.

I still use multiple roles across the workflow.

But instead of fixed specialists,

they now share a core and branch through protocols

with the constraints needed at that moment.

This isn’t about making AI better.

It’s about getting reliable, deterministic results

with proof, when partial correctness is no longer acceptable.

At this point, the problem isn’t intelligence.

It’s control over context and governance.

Each step is scoped, explicit, and verifiable.