Why My Autistic Brain Loves Hugo, Go, and Svelte (And Not React)

There’s a pattern I’ve noticed in the technologies I gravitate toward versus the ones that make me want to throw my keyboard out the window. It took me a while to articulate it, but I think I finally understand: my autistic brain craves explicitness, predictability, and direct mental models.

Let me explain.

The Technologies That Click

Hugo

Hugo is a static site generator, and that’s exactly what it does. You write content in Markdown. You write templates in Go’s template language. You run hugo, and it spits out HTML files. No webpack. No hydration. No “but first you need to understand the virtual DOM.”

The mental model is direct: input → transformation → output. I can hold the entire system in my head. When something breaks, I know exactly where to look.

Go

Go might be the most explicitly designed language I’ve ever used. There’s usually one obvious way to do something. Error handling is verbose, but it’s right there. No exceptions bubbling up from five stack frames away. No hidden control flow.

result, err := doSomething()
if err != nil {
    return err
}

Some people find this tedious. My brain finds it calming. Every possible failure is visible. Every code path is explicit. The compiler catches mistakes before runtime. There’s no magic.

Svelte

Svelte compiles away. There’s no virtual DOM diffing at runtime, no useEffect dependency arrays to get wrong, no useMemo to remember. You write:

<script>
  let count = 0;
</script>

<button on:click={() => count++}>
  Clicked {count} times
</button>

And it just… works. The reactivity is the syntax. The mental model is “this variable changed, so this part of the UI updates.” Direct cause and effect.

FastAPI

FastAPI is Python with explicit types and automatic documentation. You define your endpoint:

@app.get("/users/{user_id}")
async def get_user(user_id: int) -> User:
    return await db.get_user(user_id)

And you get: type validation, OpenAPI docs, editor autocomplete, and clear error messages. Everything is declared upfront. No Django magic methods. No Flask’s “figure out request context yourself.”

Temporal

Temporal handles workflows, and it does so with deterministic replay. Your workflow code is just code. If it fails, Temporal replays from the last checkpoint. State is explicit. Retries are automatic. The mental model is: “write the happy path, Temporal handles the chaos.”

func MyWorkflow(ctx workflow.Context, input string) error {
    // This either completes or retries. No half-states.
    result, err := workflow.ExecuteActivity(ctx, MyActivity, input).Get(ctx, nil)
    // ...
}

Clean Python (with Type Hints)

Modern Python with type hints and clear structure is a joy:

def process_user(user: User) -> ProcessedResult:
    """Transform user data into processed result."""
    return ProcessedResult(
        name=user.name.upper(),
        created_at=datetime.now()
    )

No magic. No metaprogramming surprises. The types tell me exactly what goes in and what comes out.

The Technologies That Fight My Brain

React

React hooks broke my brain. Not because they’re objectively bad, but because the mental model is indirect.

useEffect(() => {
  fetchData();
}, [userId]);

What happens when this runs? When does it not run? What if I forget a dependency? What if I add one I shouldn’t? The rules are implicit. The behavior is emergent from a complex runtime. I can never quite hold the whole model in my head.

And there are seventeen ways to manage state. Context? Redux? Zustand? Jotai? Recoil? Each with its own mental model, its own tradeoffs, its own ways to shoot yourself in the foot.

jQuery

jQuery was brilliant for its time, but it embodies implicit state:

$('.button').click(function() {
  $(this).parent().find('.content').toggle();
  someGlobalState = true;
});

Where’s the state? Everywhere. In the DOM. In global variables. In closures. In CSS classes being used as boolean flags. The mental model is “the DOM is mutable global state, good luck.”

PHP (Classic)

PHP’s standard library is a masterclass in inconsistency:

strpos($haystack, $needle)  // haystack first
array_search($needle, $haystack)  // needle first
in_array($needle, $haystack)  // needle first
array_key_exists($key, $array)  // key first

Every function is a coin flip. Parameter order? Memorize it. Return value conventions? Depends on the function. Error handling? Sometimes exceptions, sometimes false, sometimes null, sometimes -1.

My brain can’t pattern-match when there are no patterns.

The Common Thread

Looking at what I love versus what I struggle with, the pattern is clear:

This isn’t about “better” or “worse” technologies. React powers incredible applications. PHP runs most of the web. These tools work great for many people.

But for my autistic brain—which craves predictability, struggles with ambiguity, and builds understanding through clear mental models—some technologies feel like they’re working with how I think, while others feel like constant translation overhead.

Why This Matters

If you’re neurodivergent and struggling with a technology, it might not be you. The mental models of some frameworks genuinely conflict with how some brains process information.

And if you’re building tools or frameworks: explicitness is accessibility. Not everyone can hold implicit rules in working memory. Not everyone can navigate five valid approaches to the same problem. Clear, predictable, explicit design isn’t just good engineering—it’s inclusive engineering.

The best technology is the one that disappears. For me, that’s technology that says exactly what it does and does exactly what it says.