Beautiful artificial cognition for human agency.
I build software and AI artifacts around a simple belief: artificial cognition should make people more capable, not more dependent.
The goal is not a cloud oracle that rents intelligence back to humanity through a subscription gate. The goal is powerful, personal, humane tools that help ordinary people think, learn, build, create, organize, defend themselves, and shape their own lives.
That is the old personal-computer dream translated into the AI era: not institutional cognition, but personal cognition.
I am not anti-AI. I am anti-vassalization.
A bad AI future turns intelligence into a permissioned stack. Compute, models, platforms, payment rails, identity, software distribution, and work all consolidate into a handful of corporate systems. Users are told they have access, but access is not ownership. If every tool, transaction, reputation system, and creative surface can be revoked from above, abundance becomes dependency with better branding.
The better path is different.
Artificial cognition should expand human agency. It should increase a person's ability to reason, build, communicate, learn, and act. It should give people leverage rather than quietly turning them into tenants of someone else's machine.
The principles I care about are:
- human agency over managed dependency
- ownership over permission
- exit rights over platform captivity
- local capacity where possible
- transparency where it matters
- beauty and taste as part of usability
- artifacts over hype
- responsibility over inevitability rhetoric
The phrase I keep coming back to is this:
Artificial cognition as human leverage.
I care about powerful systems, but power alone is not enough.
The best tools are not merely capable. They are legible, beautiful, responsive, humane, and useful enough that people actually want to use them. Taste matters because taste decides how complexity is exposed, what agency the user keeps, and whether the tool feels like an extension of the self or a leash.
That is why I think the next great AI company should look less like an enterprise control panel and more like the Apple of cognition: frontier capability turned into beautiful personal technology.
Not AI as a corporate landlord.
AI as a bicycle for the mind, rebuilt for the age of models.
My development workflow is AI-assisted, not AI-abdicated.
I use frontier language models as collaborators, reasoning partners, implementation accelerators, refactoring assistants, and stress tests for my own specifications. But the project still has to be owned by a human.
AI can write code. It cannot own the project.
Project ownership means knowing what the system is supposed to do, why the design exists, what behavior must be preserved, where the fragile areas are, what was tested, what failed, and what should happen next.
My loop usually looks like this:
- define the product goal or failure mode
- reason through the design and constraints with an AI collaborator
- turn that into a concrete prompt, specification, or task brief
- use Codex or another implementation agent to make the change
- test the result in the real target environment
- inspect behavior, catch regressions, and refine the next step
- repeat until the artifact matches the vision
The value is in the loop: direction, specification, testing, judgment, and integration.
That is the difference between using AI as an accelerator and using it as a crutch.
A fast, minimal Safari userscript for full-resolution media previews on hover.
The project is intentionally lightweight. It focuses on responsive behavior, site-specific media handling, DOM observation, caching, browser quirks, and avoiding bloat. It is a practical example of AI-assisted development under real testing conditions, where apparently clean code still has to survive live pages and edge cases.
A tiny language-model project built as a learning and portfolio artifact.
The point is source-code fluency: moving language-model internals out of abstraction and into code that can be inspected, modified, tested, and explained. The relevant concepts include tokenization, embeddings, positional information, attention, logits, loss, optimization, and sampling.
Tater Tot is not an attempt to outbuild frontier models. It is a compact artifact for understanding how the machine works from the inside.
A running body of documentation around the human-AI development loop: how to prompt implementation agents, how to preserve project intent, how to test model-generated changes, how to recognize regressions, and how to keep ownership of a project while using AI to move faster.
As coding agents become more capable, this skill becomes more important, not less. The bottleneck is not whether a model can generate plausible code. The bottleneck is whether a person can direct powerful systems without losing the plot.
I want to help build the best artificial cognition possible and make it truly useful for people.
Not "for everyone" as fake philanthropy while the actual system centralizes power.
Not "democratized access" where the democracy ends at the subscription page.
Actually useful. Actually empowering. Beautiful enough to be loved, strong enough to matter, and designed so that people become more capable after using it.
The work I care about lives where model capability, product taste, interface design, software architecture, and human agency meet.
That is the frontier I am aiming at.
This profile is a record of turning ideas into artifacts.
The projects here are not meant to prove that I manually typed every line without assistance. That is not the point of modern AI-assisted work. They are meant to show that I can define a vision, direct AI systems, test outputs, judge behavior, preserve coherence, explain the result, and keep producing tangible work.
The standard is simple:
- build real things
- make the reasoning legible
- keep the user at the center
- use AI without surrendering judgment
- turn frontier cognition into human leverage
That is the work.