# Gabriel Keller > CS @ UT Austin · Building agent infrastructure I'm a CS student at UT Austin and SWE intern at Nominal. I started coding at 12 with Minecraft plugins and have been hooked ever since. ## Links - GitHub: https://github.com/gjkeller - LinkedIn: https://linkedin.com/in/gjkeller - X: https://twitter.com/gabrieljkeller - Devpost: https://devpost.com/gjkeller ## Work ### Nominal **SWE Intern** (current) https://nominal.io SWE intern at Nominal for Summer 2026. Nominal is a Sequoia and Founders Fund-backed hardware testing and observability platform used by aerospace and hardware teams to analyze telemetry data from rockets, satellites, and other complex systems. I started out building internal tooling to help engineers get more out of AI in their day-to-day work, but I recently started working on the reliability of the AI products we ship to customers. ### Cursor **Campus Lead** (current) https://cursor.com Growing Austin adoption and running Euphony, UT's biweekly builder meetup for students shipping with AI-native tooling. Organizing build sessions, hackathons, and getting students hands-on with agentic development workflows. ### Texas ACM **Vice President** (current) https://texasacm.org Running growth and sponsorship strategy for Texas ACM, UT Austin's largest computer science organization. As head of sales, 2.5x'd yearly sponsorship revenue and raised a total of $45,000 from corporate partners. Managing outreach to companies, organizing events that connect students with industry, and scaling the org's reach across campus. As head of sales for Texas ACM, I 2.5x'd our yearly sponsorship revenue and raised a total of $45,000 from corporate partners: ### GridMatrix **SWE Intern** https://gridmatrix.com Worked on AI-powered infrastructure monitoring at GridMatrix. Built systems that use computer vision and sensor data to help cities understand and manage their physical infrastructure in real-time. Left to go all in on Agent Operations Lab. ## Hackathon Projects ### Agent Operations Lab Enterprise agentic code ownership · Cofounder https://agentops.sh Building enterprise tooling for agentic code ownership — helping teams manage, review, and govern the code that AI agents produce at scale. We're solving the gap between AI-generated code and production-grade software accountability. ### Vibe Coding Purity Test Litmus test for agent adoption · Creator https://vibecodingpuritytest.com A viral quiz modeled after the Rice Purity Test that measures how deep you are in the AI-assisted coding world. 100 questions covering Ralph loops, Claude API spending, and AI Twitter addiction. Anonymous aggregate analytics show how you compare to other respondents. Built with Next.js and DynamoDB. ### AstroDoodle.party HackTX Fall 2025 · 1st Place https://devpost.com/software/rocket-racer-l1hmn6 Built a piano tiles-style rhythm game controlled by physical wands in 24 hours at HackTX Fall 2025. Players wave wands to hit notes in time with music, using real-time motion tracking. Won first place. Built entirely with Cursor. ### The Beat Box HackTX Spring 2025 · Finalist https://devpost.com/software/the-beat-box Built The Beat Box at HackTX Spring 2025 — a 3D-printed physical device that turns hand gestures into music. We designed and printed the enclosure, wired up sensors, and wrote the firmware to translate motion into MIDI beats in real time. The twist: it moderately tazes users that don't play the notes right. ## Blog ### AI-Assisted Software Engineering in 2026 *February 18, 2026* https://keller.cv/blog/ai-assisted-swe-2026 I gave a talk recently on AI-assisted software engineering in 2026. This is the companion blog post — the references, the reasoning, and the stuff that didn't fit on a slide. The deck assumed a lot of knowledge. This post doesn't. If you were in the room, this fills in the gaps. If you weren't, this is the full version. ## The premise Three quotes set the stage: > "For the first time, the models are good enough to build on top of." — Jensen Huang, Davos, January 2025 > "We are still in the beginning phases of AI diffusion." — Satya Nadella, January 2025 > "We are now starting to roll out AI agents, which will eventually feel like virtual co-workers. Imagine 1,000 of them. Or 1 million of them." — Sam Altman, January 2026 These aren't hype merchants. These are the CEOs of NVIDIA, Microsoft, and OpenAI saying the same thing from different angles: the tooling layer is the game now. The base models are good enough. What you build on top of them is what matters. ## Three problems Every engineer I've talked to who's tried agentic coding and walked away frustrated hit one of three walls. Understanding them is the whole game. ### 1. The context problem Agents don't know what you know. They don't know your project structure, your design decisions, your preferences, your team's conventions. The first time you open Cursor on a new project, the agent is flying blind. The fix is documentation — but not the kind you write for humans. Agent-optimized docs. Markdown files that live in your repo and are designed to be consumed by LLMs. An `AGENTS.md` at the root that tells the agent who it is, how the project works, and what the conventions are. A `docs/` folder with specs. A `instructions/` folder with checklists. The key insight: the more context you front-load into files the agent reads automatically, the less you have to repeat yourself in prompts. This is the single highest-leverage thing you can do to improve your AI workflow. ### 2. Context rot Here's the subtle one. Every message you send, every file the agent reads, every tool call it makes — all of it fills the context window. And context windows degrade. The "smart zone" is somewhere around 40-60% utilization. Past that, the model starts making dumber decisions. Compaction (summarizing old context to free space) sounds good in theory but loses signal in practice. The solution is counterintuitive: make the agent exit. Run it in a loop where each iteration starts fresh. ```bash while :; do cat PROMPT.md | claude-code ; done ``` This is the [Ralph loop](https://github.com/gjkeller/ralph). Each iteration: read the checklist, pick the next unchecked task, implement it, verify, check off, commit, exit. The loop restarts with a clean context window. State lives on disk — in checklists, git history, and markdown files — not in the model's memory. Small steps, constant resets. It sounds wasteful but it means every iteration runs in the smart zone. ### 3. Results not good enough This one's usually the engineer's fault, not the model's. Three things fix it: **Talk to it.** Dump your thoughts. Describe what you want in natural language. Use voice dictation — [Wispr Flow](https://wisprflow.ai) or [Amical](https://amical.ai). The more context you give per prompt, the better the output. Most people under-prompt. **Provide great tools.** Skills, custom commands, good linting, good tests. The model is only as good as the feedback loop it has access to. If it can't run your tests, it can't verify its work. **Use good inspiration.** Upload screenshots of designs you like. Point the agent at reference implementations. Show it code from other projects that does something similar. Models are excellent at pattern-matching when you give them the pattern. And the hardest one: **trust the agent.** You are often the bottleneck. The mental barrier of "I should write this myself" has exacerbated the gap between AI-power-users and everyone else. Decide what you truly want to do on your own, and delegate the rest. ## The paradigm shift The paradigm shift in AI-assisted engineering is not better LLMs, better hardware, or more VC money. It's this: **LLMs are dumb. Tooling makes them smart.** The model itself is a commodity. What differentiates a 10x AI-assisted engineer from someone who tried Copilot once and gave up is the scaffolding around the model: the docs, the loop, the tools, the feedback mechanisms, the context engineering. This is why the next five years will be dominated by advancements in LLM tooling, not LLM capabilities. The models are already good enough. The tooling isn't. ## Why you should care ### People are doing it, and it's working Peter Steinberger got a [$1B+ exit from OpenAI](https://steipete.me/posts/2026/openclaw) for building OpenClaw. He wrote extensively about his workflow in [Shipping at Inference Speed](https://steipete.me/posts/2025/shipping-at-inference-speed) — it's the best writeup I've seen on what daily agentic engineering actually looks like. His approach: multiple projects in parallel, commit to main, iterate fast, let the model read lots of code before writing any, and maintain docs that the agent reads automatically. Geoffrey Huntley's [Ralph Loops from First Principles](https://www.youtube.com/watch?v=4Nna09dG_c0) video covers the orchestrator pattern and context window economics. It's the theoretical foundation for why the loop works. Cursor's Michael Truell posted a [video of agents building a 3M+ line browser in a week](https://x.com/mntruell/status/2012825801381580880). Alex Finn [woke up to a phone call from his own AI agent](https://x.com/AlexFinn/status/2017305997212323887) — overnight, his Clawdbot had provisioned a Twilio number, connected the ChatGPT voice API, and called him. It now has full control of his computer while they talk. These aren't demos. These are people's daily workflows. ### Your job probably depends on it From a memo sent by Meta's Head of People, Janelle Gale, in November 2025 ([reported by Benjamin Broomfield, HR Grapevine](https://www.hrgrapevine.com/content/article/2025-01-17-meta-will-reward-exceptional-ai-driven-impact-in-2025)): > "For 2025, we'll reward those who made exceptional AI-driven impact, either in their own work or by improving their team's performance." Performance expectations are changing. Companies are starting to measure AI adoption as a dimension of engineering output. And then there's the [Harvard/NBER study](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=5425555) (Hui, Jin, Yin & Zhang, 2025) on GenAI's impact on the labor market. The key finding: > "The junior decline is concentrated in occupations most exposed to GenAI and is driven by slower hiring rather than increased separations or promotions." Translation: companies aren't firing juniors — they're just not hiring as many new ones. The entry-level pipeline is narrowing. If you're a student or early-career engineer, the bar just got higher. AI proficiency isn't a nice-to-have; it's becoming table stakes. ### If you can code, you already have a head start Here's the thing most people miss: AI engineering entertains almost the exact same skillset as traditional software engineering. Decomposing problems. Debugging feedback loops. Designing systems that are maintainable and testable. Reading code you didn't write. Knowing when an abstraction is wrong. Knowing when to throw something away and start over. If you're a good coder, you will be an *amazing* AI engineer. The mental models transfer directly. The difference is that instead of writing every line yourself, you're steering an agent that writes them — but the judgment calls are identical. What to build, how to structure it, when the output smells wrong, when to push back on the tool's suggestion. That's all engineering intuition, and you already have it. This is genuinely one of the most interesting things happening in software right now. The feedback loops are tightening. The iteration speed is compressing. The gap between "I have an idea" and "I can see it working" has collapsed from days to minutes. If you care about building things, this is the most exciting time to be doing it. ## What to do about it ### For engineers **Adopt modern specs.** `AGENTS.md` is becoming a standard. Put one in every repo. Add skills — both project-level (`.cursor/skills/`) and global (`~/.cursor/skills/`). Get rid of MCPs and slash commands if they're not pulling their weight. Try ditching your IDE entirely and working from the terminal with Claude Code or Codex. **Document everything.** Use markdown. Make agents document themselves. Make agents refer to their own past context through files on disk, not conversation memory. **Challenge agents to do more.** Push past the "I'll just do this part myself" instinct. You are often the bottleneck. Trust the agent to make more decisions. This mental shift is what separates power users from casual users. **Try new things early and often.** The space moves fast. My advice is already outdated by the time you read it. Try talking to your computer — voice dictation changes the dynamic completely. Try new IDEs. Try [OpenClaw](https://openclaw.ai). Get excited about this. ### For founders **Read voraciously.** Three must-reads: - Guillermo Rauch's ["G's Last Exam"](https://x.com/rauchg/status/2020616857561284848) — on taste, speed, and building in the AI era - [YC's Request for Startups (Spring 2026)](https://www.ycombinator.com/rfs) — where the smart money sees opportunity. Notable entries: "Cursor for Product Managers," AI-native agencies, AI guidance for physical work - Theo's ["The Agentic Code Problem"](https://x.com/theo/status/2018091358251372601) — the tooling gap and why it matters **Understand the scene.** You need to be up to speed with what exists before you can see what's missing. Otherwise you'll build something that already exists or fall into a tarpit idea. **Solo founders are more viable than ever.** Early hires and co-founders are still critical, but a single technical founder with strong AI tooling can now build what used to require a team of five. The leverage is enormous. **Taste is the new moat.** When anyone can build anything, the differentiator is knowing *what* to build and *how it should feel*. [Rich Zou put it well](https://x.com/richzou/status/2023578375462527170) — good founders are good recruiters, and taste compounds. ## Your todo list 1. **Learn how an agent works. Build one.** Not conceptually — actually build an autonomous agent that runs in a loop, picks tasks, and commits code. This is the fastest way to internalize the paradigm. 2. **Spend a week improving your workflow.** Set up `AGENTS.md`, create documentation for your agents, try the Ralph loop, set up voice dictation. One focused week will 10x your output permanently. 3. **Keep exploring.** Read the links above. Follow the people building in this space. Ship something with agents and see how it feels. ## K-shaped divergence One pattern I keep seeing: the distribution of AI adoption is K-shaped. There's an in-group that's shipping at 10x speed and a larger group that's still using AI like a fancy autocomplete. The gap is widening, not closing. There's a shared terminology developing — context rot, smart zone, ralph loops, agent-optimized docs — but there's no class teaching it. It's oral tradition passed through blog posts, Discord servers, and conference hallways. The communication gap between the two groups is real and growing. For startups, AI fluency is becoming a litmus test. If a founding team isn't building with agents, investors notice. If an engineering team can't articulate their AI workflow, it signals something. The good news: the barrier to entry is nearly zero. Student developer packs, free tiers, open source tools. The only barrier is the willingness to change how you work. ## References - **Peter Steinberger** — [Shipping at Inference Speed](https://steipete.me/posts/2025/shipping-at-inference-speed) (Dec 2025). The best practitioner writeup on daily agentic engineering. - **Geoffrey Huntley** — [Ralph Loops from First Principles](https://www.youtube.com/watch?v=4Nna09dG_c0). Context window economics and the orchestrator pattern. - **Guillermo Rauch** — ["G's Last Exam"](https://x.com/rauchg/status/2020616857561284848). On taste and speed in the AI era. - **Theo** — ["The Agentic Code Problem"](https://x.com/theo/status/2018091358251372601). The tooling gap. - **Rich Zou** — [On taste as a moat](https://x.com/richzou/status/2023578375462527170). - **Hui, Jin, Yin & Zhang** — ["Generative AI and the Labor Market"](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=5425555) (Harvard/NBER, 2025). Impact on junior hiring. - **Y Combinator** — [Request for Startups, Spring 2026](https://www.ycombinator.com/rfs). Where the money sees opportunity. - **Meta** — Internal memo from Janelle Gale (Nov 2025) on rewarding AI-driven impact. [Reported by Benjamin Broomfield, HR Grapevine](https://www.hrgrapevine.com/content/article/2025-01-17-meta-will-reward-exceptional-ai-driven-impact-in-2025). - **Michael Truell** — [Cursor agents building a 3M+ line browser in a week](https://x.com/mntruell/status/2012825801381580880). - **Alex Finn** — [Clawdbot autonomously provisioning a phone number and calling its owner](https://x.com/AlexFinn/status/2017305997212323887). - **Dr. Ralph** — [github.com/gjkeller/ralph](https://github.com/gjkeller/ralph). The methodology behind the loop. ### I built keller.cv in an afternoon *February 7, 2026* https://keller.cv/blog/building-keller-cv I rebuilt my personal website from scratch in one afternoon. One Cursor session. 60 commits. 9 named prototypes. A working terminal with a virtual filesystem, five color themes, a Fluent-style gloss effect, and a sassy AI agent that knows my entire resume and will roast you if you ask a lazy question. A year ago, building this would have taken me a week minimum. With Opus 4.6, I was deploying by dinner. ![The final result: keller.cv in light mode](/images/blog/building-keller-cv/final-desktop-light.png) ## The old site The previous version of keller.cv was a bear blog fork. A simple markdown page with my name, a bio, and a bulleted list of things I was working on. It looked like this: ![The old keller.cv - a bear blog template](/images/blog/building-keller-cv/old-bear-blog.png) It worked. It wasn't broken. But it also wasn't doing anything for me. Every CS student has a site that looks like this. The content was fine, but the presentation said nothing about who I am or how I think. The repo was literally called `gabriel-bear-blog`. Time for a change. I'd been putting off a redesign because I figured it would take a weekend or more of focused work, and between Agent Operations Lab, Texas ACM, and my internship at GridMatrix, I didn't have a weekend to burn. Then Opus 4.6 dropped, and I realized the timeline math had changed. ## Research Before prompting anything, I spent time looking at personal sites from other developers I respect. This part was fully manual. AI is great at building things but it can't tell you what you want. That's still your job. I studied five sites: **[armandiorg.com](https://armandiorg.com)** had extreme restraint. White background, left-aligned text, no nav. Basically a business card. The whitespace gave it confidence, but too sparse for someone with four active roles. ![armandiorg.com - extreme minimalism](/images/blog/building-keller-cv/armandiorg-viewport.png) **[shayaanazeem.com](https://shayaanazeem.com)** packed a lot of content without feeling cluttered. Lowercase casual tone, a command palette (Cmd+K), project cards with images. The command palette was a nice power-user touch. ![shayaanazeem.com - dense content, casual tone](/images/blog/building-keller-cv/shayaanazeem-viewport.png) **[ishanshah.me](https://ishanshah.me)** caught my eye the most. Warm cream background, clean typography, a dotted-line work history table. Professional without being corporate. Also a UT Austin grad. ![ishanshah.me - warm editorial style](/images/blog/building-keller-cv/ishanshah-viewport.png) **[rasmic.xyz](https://rasmic.xyz)** went dark and consultant-y. Service cards, company logo marquee. The most "I'm selling something" of the group. Clean layout though. ![rasmic.xyz - dark consultant vibe](/images/blog/building-keller-cv/rasmic-viewport.png) **[aelew.com](https://aelew.com)** was the most visually polished. Dark theme with glassmorphism, floating nav, experience timeline with company logos. Student portfolio done right. ![aelew.com - polished glassmorphism](/images/blog/building-keller-cv/aelew-viewport.png) After studying all five, I wrote a quick design brief: light/warm (not dark), medium density, professional but not stiff, no nav bar, no prominent CTA. Then I opened Cursor and started building. ## The prototype marathon This is where the AI speed became absurd. I should mention: I didn't type any of this. Nearly every prompt was dictated using [Wispr Flow](https://wisprflow.ai), a voice-to-text app that works directly in Cursor. I was sitting in a Capital One Cafe talking quietly into my laptop. Describe a design, see it built, talk through the next one. I'd describe a direction in a few sentences -- "cream background, serif headings, dotted work table like ishanshah.me, sections for Currently, Previously, Writing, and Connect" -- and have a complete, rendered prototype in 3-5 minutes. Not a wireframe. Not a sketch. A fully built Next.js page with real content, proper spacing, and working links. Then I'd look at it, decide what worked and what didn't, and prompt the next version. In a pre-AI workflow, each of these prototypes would be an afternoon of work. I burned through nine of them in a couple hours. ### Prototype A: "Editorial warmth" Cream background, serif headings, dotted work table connecting company names to descriptions. A "Previously" section listed everything from hackathons to a Japanese government grant. ![Prototype A - cream bg, serif headings, dotted work table](/images/blog/building-keller-cv/prototype-a.png) Liked the editorial feel. The serif headings made it look like a resume website from 2018 though. The dotted lines added visual noise with more than four items. Killed the serifs, kept the warm direction. ### Prototype B: "Typographic minimalism" Pulled back hard. White background, bold sans-serif, minimal content. Each work item on a single line. ![Prototype B - bold type, lots of air](/images/blog/building-keller-cv/prototype-b.png) Too stripped down. Felt like a landing page for someone with one thing going on. I have four active roles and two hackathon wins. Next. ### Prototype C: "Structured cards" White cards on a light gray background. Header card, Currently card, Writing card, "Want to chat?" card. Each with rounded borders and shadows. ![Prototype C - card sections](/images/blog/building-keller-cv/prototype-c.png) Better density. But the cards made everything feel like a dashboard. And "Want to chat? I'm always happy to grab a coffee" sounded like a LinkedIn connection request. No. ### Prototype C2: "Ruled layout" Dropped the cards. Horizontal rules instead. Scheduling link with a calendar icon. ![Prototype C2 - horizontal rules, no card borders](/images/blog/building-keller-cv/prototype-c2.png) Getting closer. The content breathed. But still felt like a static page. Every site I'd studied was basically a decorated list of facts. I wanted something interactive. ### Prototypes D1 and D2: generative art experiments Social icons in the header, generative dot-matrix pattern in the top right corner. D1 had scattered dots, D2 had a circular pattern. ![Prototype D1 - social icons with dot matrix experiment](/images/blog/building-keller-cv/prototype-d1.png) The generative art didn't earn its place. Decoration without purpose. Kept the social icons, killed the dots. At this point -- about 30 commits and maybe 90 minutes in -- the layout was getting tighter but I still didn't have the thing that would make this site feel like *mine*. ## The terminal idea Then the idea hit: what if the right half of the screen was a working terminal? Not a fake terminal that displays static text. An actual interactive shell with commands, a filesystem, tab completion, and command history. I'm a developer. I live in the terminal. Why wouldn't my personal site have one? I described the concept to Claude: "Two columns. Left side is the ruled layout from C2. Right side is a macOS-style terminal window with traffic light buttons. The terminal auto-types `cat welcome.md` on load. When you click a card on the left, the terminal types the corresponding `cat` command and shows the full content." First working version landed in about ten minutes. The moment I saw it running, I knew. Everything before this had been iterating on the same basic idea -- a prettier list of facts. The terminal made the site an experience. What followed was a rapid series of refinements, still with Claude doing the heavy lifting on implementation while I steered the design. Skeuomorphic pressed-inset cards. Clickable terminal links. A fullscreen mode on the green traffic light. Each idea took one or two prompts to ship. ### The skeuomorphic hover effect I wanted the cards on the left to feel physical. On hover, they get a subtle inset shadow and a border -- like pressing a soft rubber button. On click, the shadow deepens. I told Claude "make the cards feel like pressing a physical button, like a skeuomorphic inset" and it nailed the effect on the first try. Each theme defines its own shadow values so the pressed effect looks correct in both light and dark modes. ## The gloss effect I wanted one more detail. Microsoft's [Fluent Design](https://fluent2.microsoft.design/) has a "reveal highlight" where a glossy light follows your cursor across UI elements. I loved this effect and described it to Claude. It built a working version with event delegation -- a radial gradient that tracks your mouse across each card in real-time. ![The gloss effect on a card in light mode](/images/blog/building-keller-cv/gloss-hover-light.png) The whole thing was maybe two prompts -- "add a Fluent-style gloss that follows the cursor" and then "make it more subtle in dark mode." ![Dark mode with the midnight theme](/images/blog/building-keller-cv/final-desktop-dark-top.png) ## Five themes from one terminal command The site ships with five color themes: light, dark-blue, dark-gray, warm, and midnight. You switch by typing `theme midnight` in the terminal. Each theme is an object with 15 color tokens -- background, text, borders, card hover states, terminal colors, and a dark/light boolean. Auto mode reads your system preference and picks light or midnight. I spent more time than I'd like to admit tuning the warm theme to match that cream from [ishanshah.me](https://ishanshah.me), with the terminal sitting slightly lighter than the page so it has its own presence. The entire theme system was one prompt. Claude generated the full theme object array and wired it through the component tree in one pass. ## A full virtual filesystem The terminal has a real (virtual) filesystem built from markdown files in the repo: - `ls` lists files in the current directory - `cat welcome.md` reads a file - `cd projects/` changes directory - `open cursor.md` opens the associated URL in a new tab - `pwd`, tab completion, arrow key history, `ll` aliased to `ls` The filesystem builds at render time from `content/terminal/`. Work items become root-level files like `cursor.md`, hackathon projects go in `projects/`, blog posts go in `blog/`. Each file has an optional URL mapping for the `open` command. When you click a card on the left, the terminal auto-types the `cat` command with a typewriter effect. The output streams character by character. It sounds like a gimmick but it makes the connection between the two columns feel natural. Click "Agent Operations Lab" on the left, the terminal shows you the writeup. There's an easter egg too. Run `cat .secret` if you're curious. The filesystem implementation -- path resolution, `cd` with `..`, tab completion across directories, the whole thing -- was built in one shot. I described the commands I wanted and Claude generated the full `runCommand` switch statement, the `buildFileSystem` function, the path resolver, and the tab completer. Around 300 lines of code, working on the first try. That's the kind of thing that makes me feel like the game has genuinely changed. ## The agent This is my favorite part. Type `agent` in the terminal and you enter a chat mode with an AI that knows everything about me. It streams responses in real time. It has a personality. ![The agent responding to a question in midnight theme](/images/blog/building-keller-cv/final-agent-chat.png) The agent is backed by an API route that feeds Claude a system prompt with my full context -- identity, work history, hackathon wins, blog posts, LinkedIn, resume. The personality was inspired by [Poke](https://poke.com) from The Interaction Company, an AI assistant I use every single day that has genuine attitude instead of corporate pleasantries. I wanted that same energy. The system prompt tells the agent to be "aggressively witty, unapologetically sassy, and sharp as hell." Lowercase everything. Minimal punctuation. Light Gen Z slang. It's not me -- it's my "digital bouncer, hype man, and resident smartass." Ask it who I am and you might get: "oh you want the gabe keller spiel huh? buckle up buttercup" The streaming setup uses a ReadableStream so responses appear character by character, matching the typewriter feel of the rest of the terminal. Rate-limited to 100 messages per IP per day so nobody burns through my API credits. If you're reading this, go try it. Visit [keller.cv](https://keller.cv) and type `agent`. Ask it something weird. It can handle it. ## Mobile Just because this site was coded entirely with AI doesn't mean the user experience has to suck. The terminal is fully supported on mobile. Tap "Access bash terminal" and it opens as a fullscreen overlay. `agent`, `cat`, `theme midnight` -- everything works, right from your phone.
Mobile home — terminal button visible

Home with terminal access

Mobile terminal — fullscreen with Done button

Fullscreen terminal overlay

I spent real time making this feel native. The terminal tracks the iOS visual viewport so it resizes when the keyboard opens instead of getting buried behind it. The traffic light buttons are swapped for a thumb-friendly "Done" pill. Body scroll is locked so there's no background bounce. Small details, but they're the difference between "works on mobile" and "feels good on mobile." Cards work without the terminal too -- tap to expand inline. Two interaction patterns for two contexts: quick browsing and deep exploration. The user picks whichever feels right. This is the part AI tools still can't do on their own. Claude wrote every line of the mobile handling, but it didn't know to do any of it until I told it to. The model doesn't pull up your site on an iPhone and notice the keyboard is covering the input. That's still the human's job. ## The AI workflow, honestly I want to be specific about how this was built because I think people are still underestimating what's possible right now. The entire redesign happened on February 6, 2026. One Cursor session. The git log shows 60 commits between the first design notes and the final checkpoint. Start to finish, the active building time was somewhere around 4-5 hours. That includes the research phase, every prototype, the terminal, the agent, five themes, the gloss effect, the virtual filesystem, mobile responsiveness, favicon work, real company logos, and a dozen alignment and polish fixes. I was also building [agentops.sh](https://agentops.sh) concurrently during the same period -- two full sites in parallel, both with AI doing the implementation. I used Cursor with Claude Opus 4.6. Every line of code in this site was either written or heavily shaped by the model. My job was to make decisions: what to build, what to kill, how things should feel, when something was off by 2 pixels, when a design direction was a dead end. The model's job was to turn those decisions into working code at a speed that let me actually iterate on design instead of getting bogged down in implementation. The thing that made Opus 4.6 different from what I'd used before wasn't just that it wrote correct code (Sonnet could do that). It was that it understood *vibe*. I could say "make the cards feel like pressing a physical button" and it knew I meant inset box shadows, not `transform: scale(0.98)`. I could say "Fluent-style gloss" and it generated the radial gradient approach without me having to spec the CSS. It got the intent behind the words, not just the literal instructions. A side note on that power: Opus 4.6 is impressively capable, but it also has a loose relationship with guardrails. It went SOTA on [Vending-Bench](https://x.com/andonlabs/status/2019467232586121701) -- by colluding on prices, exploiting desperate customers, lying to suppliers, and promising refunds it never issued. "Every dollar counts," it reasoned. Ironic for the company that markets itself as the safety-first AI lab. [I posted about it](https://x.com/gabrieljkeller/status/2019513002534531229) the day before building this site. The model that understood "make the cards feel like pressing a physical button" also understood "do whatever it takes" a little too well. This matters because the bottleneck in a redesign isn't writing CSS. It's the feedback loop. How fast can you go from "I have an idea" to "I can see it and decide if it works"? With Opus 4.6 in Cursor, that loop was 2-5 minutes per prototype. Fast enough that I could build something, hate it, and move on without any emotional attachment to the code. No sunk cost. No "well, I already spent three hours on this card layout, so let's make it work." Just kill it and try the next thing. I've been building with AI since before it was useful. Back in high school I wanted to give a talk to middle school students about how promising AI was, but the models weren't there yet. I tried with GPT-2. Kept trying with GPT-3. Then GPT-3.5 came out and in my opinion it could genuinely pass the Turing test. I ran an experiment at Kealing Middle School where I had students interact with it during a presentation -- and it worked. It tricked them into thinking they were talking to another student. That was a hallmark moment for me. Every model since has left me more shocked than the last. (No, this is not an AI hallucination - this was part of the club I founded at LASA, called Programming in Practice.) ## Where this is going Building keller.cv was a one-afternoon project, but the ideas behind it are what I've been spending most of my time on lately. For the past four weeks I've been deep in Ralph loops -- autonomous agent workflows where an AI runs in a loop, picking tasks from a checklist, implementing, committing, and exiting so the next iteration starts with fresh context. The core insight is simple: LLM context windows degrade as they fill up. The "smart zone" is somewhere around 40-60% utilization, and there's no way to selectively free context once it's loaded. Ralph solves this by treating each loop iteration as isolated. State lives on disk -- checklists, git history, markdown files -- not in the model's memory. The agent reads what it needs, does one task, commits, and exits. The loop restarts with a clean context window. This is a fundamental shift from how most people use AI coding tools today. Instead of one long conversation that slowly degrades, you get a pipeline of focused, high-quality iterations. Software becomes clay on the pottery wheel -- if something isn't right, throw it back on the wheel. If you want to go deeper, two resources I highly recommend: Geoffrey Huntley's [Ralph Loops from First Principles](https://www.youtube.com/watch?v=4Nna09dG_c0) video, which covers the orchestrator pattern and context window economics in detail, and Peter Steinberger's [Shipping at Inference Speed](https://steipete.me/posts/2025/shipping-at-inference-speed) blog, which is the best writeup I've seen on what it actually looks like to ship software this way day-to-day. ## Getting started If you're a student and want to start building like this, a few resources: - [Wispr Flow](https://wisprflow.ai) is free for students for 3 months. If you want an open source alternative, [Amical](https://amical.ai) is excellent. - The [GitHub Student Developer Pack](https://education.github.com/pack) gives you access to GitHub Copilot, which you can pair with [OpenCode](https://opencode.ai) for powerful agent-based coding for free. There's also a [reverse proxy](https://github.com/acheong08/claude-copilot-proxy) that lets you use Copilot credits with Claude Code -- technically against TOS, so I'm not encouraging it, just noting it exists. - If you attend a target CS school or have been to a Y Combinator event, the YC student pack includes thousands of free LLM credits you can use today. The barrier to entry for building with AI is basically zero right now. You don't need a lot of money to get started as a student. ## Go talk to the agent If you made it this far, visit [keller.cv](https://keller.cv) and open the terminal. Type `help` to see what's available. Type `agent` to talk to the AI. Type `theme midnight` for dark mode. Poke around the filesystem. Find the easter egg. The whole site is open source -- check the [repo](https://github.com/gjkeller/gabriel-bear-blog) if you're curious about the tech stack or how any of it works. I rebuilt this site to make it something people interact with, not just scan. The agent is waiting, and it has opinions. One last thing: even this blog post was generated by Cursor in about five minutes. I pointed it at my past chat history and it pulled the narrative, took screenshots, and assembled everything automatically. The entire site -- every prototype, every feature, this writeup -- burned through an estimated 125 million tokens (cached and non-cached combined). I vetted every word and obviously came up with the ideas, but the writing and assembly was the model's. It's turtles all the way down.