About Haochuan

Building personal intelligence systems.

I’m Haochuan Zhang, a software engineer and independent builder working across agentic software engineering, local AI infrastructure, personal computing, and wearable interfaces.

Most of these projects return to one practical question:

How can individuals turn abundant machine intelligence into durable capability without surrendering agency, context, or accountability?

I think of the answer as a personal intelligence system: the compute that supplies model capacity, the agents and tools that perform work, the interfaces through which a person directs them, and the permissions and evidence that keep that person responsible.

What I build

My most visible project is CyberHUD, an iPhone-hosted programmable HUD for compatible USB-C display glasses. It began because I wanted a useful clock in my glasses. It grew into a focused Desktop with native and bundled web applets, optional stereo presentation, and a bounded creation system called Netics. The month-one build log records how each useful feature exposed another product or engineering boundary.

Netics lets AI create small Custom Applets inside an explicit product contract. Generated source has to fit declared interfaces and pass native validation before the product accepts it, and generation begins only after an explicit user action. The host retains control of capabilities, permissions, credentials, and storage boundaries. This makes personal software easier to create while keeping the safe path visible and understandable.

Alongside CyberHUD, I run local-model and personal-compute experiments. I care about what a model can actually do on hardware I control, where it fails, and which surrounding systems make it usable. My DeepSeek V4 Flash experiment, for example, became a whole-machine systems problem involving GPU topology, host memory, NVMe storage, precision, power limits, and failure containment.

I also publish developer and agent tools, including integrations for Blender, Sketch, and Xcode. These projects occupy different layers of the same stack: compute supplies capacity, agents turn capacity into execution, product boundaries make that execution useful, and personal interfaces keep the person in control.

How I work with AI

In much of my AI-assisted work, producing a first attempt is no longer the scarce part. Context, judgment, integration, and verification are.

I use models as collaborators and bounded operators inside an engineering system. Agents may investigate, implement, test, review, or simplify. Before I delegate execution, I try to define the intent, constraints, permissions, and evidence required for acceptance. During research, design, and debugging, I leave room for the original thesis to change when the evidence points elsewhere.

AI can accelerate execution. I remain responsible for direction, integration, physical testing, provider spending, safety, rights, publication, and the consequences of the result.

A capable model helps, although the durable multiplier comes from the system around it: specifications, tools, validation, tests, repeatable handoffs, and human review. The model is replaceable. The context, standards, and responsibility should remain mine.

I also try to keep the boundaries of evidence explicit. A passing test proves only what it tested. A successful render does not prove physical comfort. A reproducible artifact can still lack approval, suitable rights, or a truthful public claim. When I do not know, I would rather say so and continue investigating.

What I write

The work here tends to fall into several connected areas:

  • agentic software engineering, orchestration, and human–AI collaboration;
  • local models, personal compute, and AI infrastructure;
  • CyberHUD, wearable computing, and focused display interfaces;
  • personal knowledge systems, memory, permissions, provenance, and governance;
  • product build logs, validation, release work, and design decisions;
  • learning, cognitive independence, and human agency;
  • speculative technology and culture; and
  • occasional travel, photography, gadgets, and internet weirdness.

Some posts report direct implementations, measurements, failures, and reproducible experiments. Others are interpretation or scenario-building. I try to keep those modes visible so a compelling story does not quietly become an established fact.

Why this blog exists

This blog is my long-term memory, build journal, and intellectual test bench.

Product pages should describe what currently exists. Repositories should hold reproducible artifacts. This blog records the slower layer: why I made a decision, which paths failed, what evidence changed my mind, how a system evolved, and which claims remain uncertain.

Writing in public makes ideas easier to examine and harder to quietly rewrite after the fact. It leaves me a record of what I believed, what I built, what worked, and where I was wrong.

I keep that record on a part of the web I control. Social feeds are useful for distribution, but they are poor long-term memory. I want this site to behave more like a notebook than a casino. The original essay, “Why I Keep a Personal Blog in the Age of AI”, explains that choice in more detail.

My current answer to the question behind this site is a build program: make intelligence useful, bounded, inspectable, portable, and answerable to the person using it. This blog is where I keep the evidence, revisions, and parts that did not work.

Explore next

Colophon

This is a statically published site built from Markdown and version-controlled source. I do not run behavioral analytics or engagement mechanics.