Built in One Session: From Empty Repo to Deployed Presentation

The footer of the presentation reads: “Built in one session: human intent, AI hands, zero copy-paste.”

That line is both true and incomplete. Let me tell you the full story.

The Task

I needed a mobile-first teaser presentation for my agentic engineering training business. Something I could share on a phone, something that communicated the core idea quickly, something that looked like it was built by someone who actually knows what they’re doing with agents.

I had clear requirements:

• Seven slides
• Mobile-first canvas: 390px wide, 9:19.5 aspect ratio (iPhone proportions)
• Animated hero section with a visual of agent orchestration in action
• ASCII art progression showing developer levels
• Speech bubbles, particle effects, visual polish
• A WhatsApp CTA button at the end
• Deployed to GitHub Pages, live URL, shareable immediately

The tool: Slidev. If you haven’t used it, Slidev is a presentation framework where slides are written in Markdown with Vue components. Code-driven, Git-friendly, deployable as a static site. It was the right choice for this — agents can write Slidev slides as naturally as they write any other code.

I started with an empty Git repository. No scaffold, no starter template, no “I copied a previous project.” Blank.

What Actually Happened

The session was massive. 300,000+ tokens across three context windows. That was a first for me — a single project requiring multiple context window resets. Not because the context hit the limit in a problematic way, but because the session was long enough and complex enough that we were doing deliberate handoffs: summarize state, open fresh context, continue. (For a sense of scale: this was a fraction of the 16-hour, million-token session I’d run on a full web application.)

Context window 1 handled the foundation: project structure, Slidev configuration, the first pass at all seven slides, mobile layout, the basic visual system. This took longer than expected because mobile-first Slidev is genuinely uncommon — most Slidev presentations are landscape, 16:9, designed for projector screens. Adapting the canvas configuration for a portrait phone layout required some back-and-forth with the Slidev documentation.

Context window 2 tackled the visuals. The animated hero. The ASCII art progression (which I’ll get to in a moment). The particle effects. The speech bubbles. Each of these was a mini-project inside the session — specific components with specific behaviors, iterating until they looked right on a real phone screen.

Context window 3 finished the deployment: GitHub Actions workflow, gh-pages branch setup, DNS verification for the subdomain, the final polish pass, and the copy review. The deployment was the least creative part and still took a non-trivial amount of time — mostly because GitHub Pages deployment for a Vite-built Slidev presentation has enough configuration surface area that getting it exactly right involves several rounds of checking.

The Part That Surprised Me

The ASCII art.

I wanted a visual showing the developer level progression — L0 through L∞, the core concept of the agentic engineering training. The agent produced something like this:

L0  ░░░░░░░░░░░░░░░░░░░░  still googling "how to use AI"
L1  ████░░░░░░░░░░░░░░░░  copy-pasting from ChatGPT
L2  ████████░░░░░░░░░░░░  using Copilot, reviewing output
L3  ████████████░░░░░░░░  giving agents tasks, checking results
L4  ████████████████░░░░  orchestrating multi-agent workflows
L∞  ████████████████████  agents build agents

I didn’t specify that format. I described the concept — a progression bar showing developer levels with the agentic engineering framing — and the agent chose ASCII. Then it animated it: each bar filling in sequence, delayed to land on the slide’s rhythm.

That was genuinely creative problem-solving. Not “here is what you asked for.” More like: here is a form that serves your content better than what you probably imagined.

I’ve seen this happen before — agents occasionally produce something better than what you specified. When it happens, you stop and recognize it. You don’t override with your original idea just because it was yours.

The Meta-Joke

There’s an obvious meta-layer here that I want to name explicitly: this was a presentation about AI agents, built entirely by AI agents, to be used to sell training on AI agents. (The website you’re reading was built the same way — the full story is in I Let AI Build This Website.)

The footer wasn’t clever branding. It was documentation.

Every slide was conceived by me — the ideas, the structure, the narrative arc, the specific points I wanted to make. The code that brought those slides into existence was written by agents. The design choices — color palette (dark mode, emerald accents), typography (monospace for code elements, clean sans-serif for copy), animation timing — were made by agents following my direction. The deployment pipeline was set up by agents.

I did not write a single line of code. I did not copy-paste a single snippet. My hands didn’t touch the keyboard except to review, redirect, and approve.

And yet the presentation is unmistakably mine. The voice. The opinions. The framing. The things it chooses to say and the order it says them in. Those aren’t generated — they were directed.

”Human Intent, AI Hands” — What That Actually Means

This phrase is doing real work in the footer, and I want to unpack it because it’s easy to misread.

It doesn’t mean “the AI had good ideas and I approved them.” It means the human provided the intent — the direction, the vision, the judgment calls — and the AI executed the implementation.

Some things I decided explicitly:

• Seven slides, this order, this progression
• Mobile-first because most sharing happens on phones
• WhatsApp as the primary CTA because that’s how I actually work
• Emerald green because it’s the brand color across all my materials
• No bullet-point slides — everything visual, everything dynamic

Some things the agent decided within those constraints:

• The specific Slidev configuration for portrait mobile
• Which Vue transition effects to use for each slide
• The exact animation timing on the hero orchestration visualization
• The ASCII art format for the level progression
• The specific GitHub Actions workflow steps

The division is: what and why are human. How and with what are AI.

This matters for anyone thinking about agentic engineering as a skill worth developing. The skill isn’t prompting. The skill isn’t “describing things to AI.” The skill is having strong enough opinions about what you want that you can direct an agent to build it without losing your intent in translation.

If you don’t have clear opinions, you get generic output. If you have clear opinions but can’t communicate them, you get close-but-wrong output. If you have clear opinions and can communicate them precisely, you get the thing you wanted faster than you could have built it yourself.

The third case is what happened in this session.

After Deployment

The presentation went live on a custom subdomain. I shared it.

The response was immediate. Not because the presentation was technically impressive — a seven-slide Slidev site is not technically impressive. Because it demonstrated exactly what it was describing.

Someone who runs agentic engineering training built their own marketing presentation with agents, in one session, and deployed it with a custom domain, and then shared it as proof. The content and the method were the same thing. That’s the kind of coherence that lands differently than a slide deck someone made in Keynote.

A few people asked: “How long did it take?” Three context windows. Maybe eight hours of wall time. Maybe four of actual agent execution time. For a deployed, polished, animated mobile presentation that I could put in front of a client.

When I started that session, I had a blank repository. By the time I closed it, I had a URL.

What Made This Possible

I want to resist the narrative that this is easy or that anyone can do it without preparation.

The session was smooth because I had months of experience directing agents on creative-technical projects. I knew when to push back on an output, when to accept the agent’s judgment over my initial idea, and when to be specific vs. when to leave room for the agent to solve the problem its own way.

I had a clear brief. Not a vague idea — a specific vision with specific constraints. Agents produce better work when the problem is well-defined. The brief for this presentation was precise enough that the agent knew what success looked like.

I had the right infrastructure. Cairn — the system I use — has context management built in, which made the three-window handoffs manageable rather than painful. Without that, a 300K token session would have been harder to navigate.

None of this negates the result. But the result doesn’t happen without the experience behind it.

That’s actually the point of the training I run: not “here’s how to prompt AI” but “here’s how to develop the judgment to direct agents well.” The footer says “human intent.” Growing that intent — making it clearer, more specific, more informed — is the work.

The empty repository filled up in one session. What filled it was months of learning how to direct the filling.