SCROLL000%

Eassa Ayoub

Cognitive-First Systems · Former Operator

Most software makes users carry its complexity. I build software that feels like thinking— systems that match how humans actually work.

The question is never "is this complex?" It's "WHO carries the complexity?" I vote computer.

Eassa Ayoub - Cognitive-first systems architect

It usually starts smaller than people admit.

One more dropdown.

One more field.

One more place to remember what the system forgot.

Then someone says, "I'm just bad at this."

They're usually not.

The system is handing its bookkeeping to a human.

I build the other way.

Here's the pattern I can't unsee:

Every layer you add is complexity the user eventually carries. Transfer it back to the machine.

Ever seen a grown adult break down over a password reset?

Ever watched someone avoid their CRM like it's a haunted house?

Seen a colleague stare helplessly at a screen overloaded with dropdowns?

Heard someone sigh, "I'm just bad at keeping track of things"—when the real problem is their tools?

Cognitive Overload

Mental exhaustion caused by badly designed systems.

Most overload doesn't arrive as one dramatic failure. It arrives as dozens of tiny decisions the system could have made itself.

This isn't about special modes or accessibility theater. Cognitive ease is just better engineering. If it's easier for the most overloaded user, it's smoother for everyone.

Full Stack
METAL
where cycles matter
RUNTIME
where state lives
PRODUCT
where users live
INTELLIGENCE
where patterns emerge
RustWASMCargo
TypeScriptEffectNode.js
AstroReactConvexVitest
MCPAgents
METALRUNTIMEPRODUCTINTELLIGENCE

Common questions

What people ask before they reach out.

My prototype works in the demo and falls apart with real users. Is it salvageable?

Almost always — it's the most common reason people call. The demo isn't the problem; the demo is proof the idea works. What's missing is everything that happens after it stops being a demo: the race conditions, the edge cases the model never handled, the architectural debt that only surfaces under real load and real failure. Most AI-assisted code gets you 80% there. I handle the 80% that's left.

When are you the wrong person to call?

When you just need more features bolted onto code that already works — that's not architecture, and you'd be overpaying me for it. When you're shopping for the cheapest option, because I'm not it. And when you don't think type safety and tests are worth the time, because that's the whole mechanism I work through, and we'd spend the engagement arguing about it. I'd rather tell you now than invoice you to find out.

Do you consult, or do you actually build it?

Both, depending on what the problem needs. Sometimes it's an architecture review and a diagram you hand to your own team. Sometimes it's me in the codebase doing the rebuild. I also take fractional CTO work when the fit is genuinely there. If you don't know which one you need yet, that's a normal place to start.

What does "compliance-by-architecture" actually mean?

That the rule compiles instead of living in a policy doc. A healthcare tool leaking PII got rebuilt with local-only processing — HIPAA-safe by construction, not by promise. Loan rules scattered across spreadsheets got encoded into a type system, so an illegal loan became a compile error. The constraint stops being something a human remembers to check and becomes something the build refuses to produce.

What makes this "cognitive-first" and not just good engineering?

The question is never whether a system is complex — it's who carries the complexity. Every layer you add is complexity the user eventually carries, so I collapse layers instead of adding them: fewer hops in the architecture, fewer decisions on the screen. Working memory is finite. Build for that, or build friction.

Let's Build

I want teams building real systems — or rescuing promising ones from prototype purgatory.

AI that earns its keep

Features that do the work — not a chatbot bolted to your dashboard so the deck looks current.

Systems shaped like your team

Workflows built around how you actually think — not how the SaaS you're escaping wanted you to.

Fewer decisions, on purpose

Every dropdown is a tax on someone's attention. I collect less of it.

Before I built systems, I ran them

Mortgage. Accounting. Sales. The work where a clumsy interface isn't a bad review — it's someone's close, someone's money, someone's mistake to sign off on.

So I don't treat complexity as abstract. It's a cost, and someone always pays it — usually the person with the least room to.

That's the lens. Work with me and it's the question I keep asking about your product: who's carrying this — and can we hand it to the machine instead?

The pattern persists