# Story
I did not enter software through the normal pipeline.
The shortest version of what I do now: I take important workflows that are
messy, undocumented, and operationally painful, find the real source of truth
inside them, and turn them into working products end to end.
That is the part I sell. Not "I know Python." Not "I build AI apps." The edge
is being able to walk into a system where the business rule is half code, half
spreadsheet, half dashboard, half memory, and still ship something smaller,
clearer, and useful.
I graduated with a degree in law in 2015. That same year, before entering
practice, I did a short stint as a marketing associate at an edtech platform. It
was one of the first times I got close to education as a business, and one of
the first times I seriously played with HTML, CSS, and marketing copy.
That period mattered more than it looked. It gave me an early feel for making
things on the internet before I had the vocabulary for product engineering.
## Law And Code Were Parallel
From late 2015 to April 2022, I worked in intellectual property law.
But the real arc was not "law, then software." During those same years, I was
teaching myself to code beside legal work. I was building legal judgment and
technical ability in parallel, while becoming more convinced that the people
with the deepest leverage were the ones building systems, not just advising
around them.
Law still shaped how I work:
- read dense systems under pressure
- care about edge cases and failure modes
- find the real source of truth
- make the argument hold when the room is hostile
- separate institutional habit from actual design
That training never left. I just switched mediums.
My law background matters because it trained me to read hostile, ambiguous
systems carefully. My software work matters because I now turn that reading
into products.
## The Indie Hacker Bet
By mid-2021, the technical track had become strong enough that I jumped into
entrepreneurship.
From June 2021 to September 2022, I worked as a solo indie hacker and built
three full-stack Laravel products from scratch. I handled the whole loop:
market research, backend and frontend development, branding, direct sales, and
more than 50 events and networking loops to force adoption and tighten feedback.
It was not polished startup cosplay. I financed part of that stretch through a
personal credit-card loan. The experiment failed. I had to find my way back to
the job market with real pressure behind me.
The important part is that I did not have to go back to law.
## Proving Depth At Wiom
Wiom hired me in October 2022 as an Entrepreneur-in-Residence. My read is that I
was initially seen more as someone useful for marketing, communications, and
general problem-solving range than as someone who could go technically deep.
I took the role anyway because I needed to service the loan, get back into the
arena, and prove depth through work instead of narrative.
That is basically what happened.
One of the hardest things I ended up owning was Genie, a legacy supply
forecasting system. The original creator had left. The algorithm was
undocumented. Business logic was tangled with transformations, boundaries were
unclear, and outputs were unreliable enough that ops teams were manually
correcting them almost every day.
During high-demand periods, it could over-allocate inventory by 30-40% in some
cases and under-allocate badly in others. I reverse-engineered the old behavior,
rebuilt and redeployed the system with zero downtime, and later integrated ML on
top of the rewrite. That work raised supply efficiency by about 20% overall.
That was not the only thing.
In 2024, I built CRM Forge, a roughly 7,000-line platform that provisions custom
CRM workflows from JSON configs in 2-3 minutes, replacing five legacy systems
totaling around 100,000 lines of code.
In 2023, I built Happy, which cut call-center dependency by about 5x using a
telephony bot, a lightweight CRM for escalations, and a Hindi/Hinglish AI
chatbot for brand-consistent scripting.
I also used my law and IP background beyond the formal role to help shape IP
strategy and support fundraising through pitch decks and investor diligence.
## The Work I Trust Most
The problems I trust myself on now sit between product, operations, data, and
engineering:
- the workflow is real, but scattered across tabs, spreadsheets, and tribal
knowledge
- the original builder is gone and the system still has to survive
- the actual source of truth is blurry or trapped inside one operator's memory
- the current tool adds ceremony instead of reducing it
- people need speed and clarity, not another layer of software
I like that kind of mess. A normal backend engineer may wait for clean specs, a
data scientist may wait for clean data, and a product manager may wait for
engineering bandwidth. I can usually move before the organization has fully
named the problem: find the rule, model the workflow, build the Python/data
layer, shape the interface, and ship something operators can actually use.
## Why Terminal-Native Became The Center
Since around mid-2025, I have become almost obsessively focused on CLI and TUI
tools because I have a specific intuition about where AI is heading.
My bet is that the real productivity jump will not come from putting better
models inside the same old GUI habits. It will come from stacking the
environment properly:
- layer 0: Vim/Emacs-style touch-typing muscle memory
- layer 1: a keyboard-first Linux environment
- layer 2: a CLI/TUI-based contractual system that lets agents do exactly what I
want, reliably, without me fighting the interface
That intuition has driven the last year of public work: terminal-native tools,
keyboard-first systems, shell-first workflows, and agent-facing abstractions
that feel closer to how I actually think and work.
## Public Tools Matter More To Me Than Portfolio Theatre
A lot of my public work is me refusing to accept bloated software as normal.
I do not think most daily software pain comes from missing features. I think it
usually comes from the wrong container, the wrong interaction model, and too
much ceremony around simple tasks.
Instead of collecting "projects" as portfolio props, I keep building tools I
actually want:
- `tm` -> repo: https://github.com/ryangerardwilson/tm | because tmux sessions
should not live as private shell folklore when they can be named, restored,
killed, and maintained as a product surface
- `xyz` -> repo: https://github.com/ryangerardwilson/xyz | because most task
systems reward anxiety, list grooming, and fake productivity instead of real
outcomes
- `rt` -> repo: https://github.com/ryangerardwilson/rt | because AI slop erodes
intuition unless drills harden real patterns into muscle memory
- `vixl` -> repo: https://github.com/ryangerardwilson/vixl | because large
spreadsheets become slow, opaque, and visually noisy long before the work is
actually hard
- `gvim` -> repo: https://github.com/ryangerardwilson/gvim | because I wanted a
richer document surface than raw markdown without surrendering Vim to Word or
browser-note slop
- `o` -> repo: https://github.com/ryangerardwilson/o | because "show in folder"
should not dump me into a mouse maze when I already live on `hjkl`
- `rlc` -> repo: https://github.com/ryangerardwilson/rlc | because local music
playback should not require an overlit GUI when `ffmpeg`, curses, and a
search bar are enough
- `erza` -> repo: https://github.com/ryangerardwilson/erza | because some docs
and tools belong in the terminal, not in tab sprawl dressed up as modern UX
- `Personalized Agentic Tooling Stack` -> components:
https://github.com/ryangerardwilson/slack,
https://github.com/ryangerardwilson/gmail,
https://github.com/ryangerardwilson/gdrive,
https://github.com/ryangerardwilson/gcal,
https://github.com/ryangerardwilson/replyguy,
https://github.com/ryangerardwilson/x,
https://github.com/ryangerardwilson/linkedin,
https://github.com/ryangerardwilson/blog | because personal workflows should
be shell-first and agent-steerable, not scattered across browser tabs
The point is not that one repo is the crown jewel. The point is the pattern:
when a workflow annoys me enough, I try to turn the real rule into a smaller,
faster tool that I can operate from the keyboard and that an agent can inspect
without begging a browser UI for permission.
This public repo trail is the cleanest way to understand me:
https://github.com/ryangerardwilson
## What I Am Optimizing For Now
I think we are heading into a real transition in how people work, learn, and
create leverage.
As AI gets stronger and old assumptions around knowledge work start breaking
down, a lot of software, institutions, and workflows will need to be rebuilt
from first principles. That is the kind of transition I want to spend my career
inside.
I want to become unusually good at a narrow but durable combination:
- operational ambiguity into shipped software
- terminal-native product design
- agentic software and AI workflows
- model-backed operational systems
- opinionated interfaces with real taste
I care less about looking modern than about building things that feel authored,
fast, and exact.
I also spend a lot of time relearning math and physics from the intuition up,
because I do not trust shallow understanding and I do not want AI to turn my
brain into paste.