Vibe Code Camp Distilled

Dan Shipper - Vibe Code Camp Demo

Dan Shipper, Co-founder and CEO of Every

Dan Shipper - Vibe Code Camp Demo

Speaker: Dan Shipper, Co-founder and CEO of Every

Key Insights

Summary

Dan Shipper, co-founder and CEO of Every, opened Vibe Code Camp with demonstrations of agent-native applications he’s built using Claude Code and Cursor. His primary demo focused on Proof, a markdown editor designed for human-agent collaboration, and Anecdote, a health tracking app that connects to Apple Health data.

The presentation emphasized Every’s philosophy of “agent-native” software development, where AI agents are the core of applications rather than traditional rule-based code. Dan demonstrated how non-engineers can build sophisticated software by leveraging tools like Claude Code, Cursor, and Every’s internal tools like Monologue (dictation) and the compound engineering plugin. Throughout the session, he worked live on improving Proof’s agent presence features, showing his actual workflow of speaking requirements into Monologue, generating plans, and iterating on features in real-time.

Main Topics

Every’s Business Model and Offerings

Every operates on three pillars for paid subscribers: Ideas (daily newsletter covering new AI models and products, plus long-form essays on AI usage), Apps (Quora for email, Monologue for dictation, Spiral for ghostwriting, Sparkle for file organization), and Training (camps and courses on AI workflows). [00:01:29 - 00:02:54]

The Vibe Code Camp event was offered free as an 8-hour marathon showcasing “the best Vibe Coders in the world,” with the full agenda available at every.to/agenda. [00:00:31 - 00:01:00]

Proof: An Agent-Native Markdown Editor

Proof is Dan’s main demo project - a markdown editor built specifically for human-agent collaboration. Key features include:

Human vs AI authorship tracking: Text appears in different colors based on who wrote it. Users can mark sections as human-written with a keyboard shortcut (turns purple for AI-written content). [00:11:27 - 00:11:52]

“What’s really cool is it has this what’s written by human and what’s written by AI here. And it’s really easy for me, for example, to go into a part of the document and press a command shortcut and you’ll see it turns purple.” [00:11:32 - 00:11:39]

Comments and track changes: Standard collaborative editing features like comments and suggested changes. [00:12:07 - 00:12:31]

Built-in agent with style guide enforcement: Users can invoke “Run review every style guide” which launches an internal agent that makes corrections according to Every’s editorial standards in real-time. [00:13:08 - 00:13:33]

“So I can press every style guide. And what it does is it launches a proof agent. So proof has an, is an agent native. So it has an agent inside of it that is going to go through the document and make changes as we’re talking.” [00:13:28 - 00:13:38]

External agent presence: Claude Code or other external agents can connect to Proof and interact with open documents. Dan demonstrated a “presence demo” where Claude connects to Proof and makes comments on a document, with the editor automatically following the agent’s cursor around the document. [00:15:21 - 00:16:03]

“What’s really cool is it’ll follow the agent around to different parts of the document as it’s making changes. And like, that’s just, I don’t know. I just feel like this is kind of fucking wild.” [00:15:57 - 00:16:03]

Development timeline and technical knowledge:

“That’s fucking crazy that I could build this in between meetings. And it’s, I started this like two less than two weeks ago… This is a project that should have taken like engineers, like a group of 300 years, like six months to do. And this is something that I, I just vibe coded in my spare time and I have absolutely no idea how any of the code works.” [00:12:37 - 00:12:55]

Agent-Native Architecture Principles

Dan referenced Every’s guide on agent-native apps (available at every.to/slash/guide/slash/agent/native) and explained core principles: [00:25:44 - 00:26:08]

Core concept: “The core of the software you’re building is just an agent. It’s like cloud code at the center of all your software… every time you press any kind of button or anything in the app, it’s actually sending a prompt to an agent.” [00:26:01 - 00:26:13]

Parity principle: Whatever the user can do through the UI, the agent should be able to do. [00:26:36 - 00:26:44]

Granularity principle: Tools available to the agent should be smaller and more primitive than features, allowing agents to combine them in novel ways. [00:26:50 - 00:27:00]

Practical example of granularity: Dan demonstrated asking Proof to “clear all comments” - a feature he hadn’t explicitly built. Because the agent has access to all the same tools as the user, it figured out how to resolve each comment individually. [00:27:25 - 00:28:13]

“I can say at proof, can you clear all of the comments here? And because the agent can do anything the user can do, even if I haven’t built this feature explicitly, it just knows how to do it.” [00:28:01 - 00:28:06]

Live Development Workflow

Dan demonstrated his actual workflow for improving Proof during the stream:

  1. Voice input with Monologue: Spoke requirements for agent presence improvements including showing agent logos, removing empty UI states, adding a “follow glow” effect, and fixing scrolling bugs. [00:19:35 - 00:21:24]

  2. Transcription and planning: Monologue transcribed the speech, which Dan pasted into Claude Code. [00:21:42 - 00:21:50]

  3. Compound engineering plugin: Used Kieran’s planning feature from the compound-engineering plugin to generate a detailed implementation plan in a work tree. [00:22:02 - 00:22:21]

  4. Parallel investigation: While the planning ran, Dan started a separate Claude conversation to investigate why the review skill wasn’t working well. [00:23:00 - 00:23:39]

Tools in the workflow: - Warp terminal with Claude Code and Cursor open side-by-side - Monologue for voice-to-text transcription - Compound engineering plugin for structured planning - Git worktrees for isolated feature development

Anecdote: Agent-Native Health App

Anecdote is a health tracking iOS app that connects to Apple Health data with an agent at its core. [00:28:36 - 00:29:02]

Chat interface: Users can ask questions like “Can you look at how I slept last night and compare it to my glucose?” and the agent analyzes Apple Health data. [00:28:53 - 00:28:59]

Personal impact: Dan used it to discover that his poor sleep was caused by glucose crashes. [00:29:13 - 00:29:19]

Collaborative journaling: Both user and agent can write journal entries to a shared feed. The agent can read user entries and write its own, creating a collaborative health tracking experience. [00:29:24 - 00:29:52]

Morning briefing: Learns user health goals and provides personalized morning insights on what to track. [00:29:52 - 00:30:02]

“You have access to the same data and the same feed of journal entries and documents… And it can help you kind of figure out your health.” [00:29:47 - 00:29:58]

Planned Improvements for Proof

Dan outlined specific features he wanted to build during the stream:

Goal: Make Proof ready for internal testing by Every’s editorial team (not just engineers) by the end of the day. [00:11:03 - 00:11:17]

Actionable Details

Tools and Products Mentioned

Workflows Described

Voice-to-Code Workflow: 1. Open Monologue and speak requirements naturally 2. Let Monologue transcribe (handles noise, stutters, etc.) 3. Paste transcription into Claude Code or Cursor 4. Use compound engineering plugin’s /plan command to generate detailed implementation plan 5. Execute plan in isolated git worktree

Agent-Native Development Pattern: - Build primitive tools/actions that both users and agents can access - Define features as prompts/skills rather than hardcoded logic - Ensure parity: anything a user can do, an agent should be able to do - Use granular tools: make tools smaller than features so agents can compose them creatively

Live Development During Stream: - Run multiple Claude Code conversations in parallel (planning in one, investigation in another) - Use git worktrees to isolate experimental features - Merge PRs between demo sessions - Test features live while building them

Resources

Configuration/Technical Details

Proof’s Review Skill: - Menu option: “Run review every style guide” - Launches internal agent that reads Every’s style guide - Makes corrections in real-time with track changes - Dan noted it was “not quite good enough” and failing frequently, requiring investigation [00:22:38 - 00:23:09]

Git Worktree Usage: - Dan mentioned using worktrees for the agent presence improvements - Specifically requested Claude to “make sure you do this in the current presence work tree” [00:21:13 - 00:21:21]

Monologue Integration: - Appears as a separate window/app - One-button press to transcribe - Handles live speech with interruptions and corrections - Outputs clean text ready for pasting into development tools

Quotes Worth Saving

“That’s fucking crazy that I could build this in between meetings. And it’s, I started this like two less than two weeks ago. And I’ve only demoed you like half of what’s here. This is a project that should have taken like engineers, like a group of 300 years, like six months to do. And this is something that I, I just vibe coded in my spare time and I have absolutely no idea how any of the code works. We’re living in, we’re living in crazy times.” [00:12:37 - 00:13:01]

“What’s really cool is it has this what’s written by human and what’s written by AI here. And it’s really easy for me, for example, to go into a part of the document and press a command shortcut and you’ll see it turns purple. And then we have written by AI. And what’s, what’s also really interesting is if you open a plan that was written all by an AI, it will just show all purple and then you will be able to track, okay, what parts of it have I changed and what parts of it are from me versus from the AI.” [00:11:27 - 00:11:52]

“The core of the software you’re building is just an agent. It’s like cloud code at the center of all your software… And basically every time you press any kind of button or anything in the app, it’s actually sending a prompt to an agent. And that’s very different from traditional software where the software is prebuilt with rules that a programmer writes.” [00:26:01 - 00:26:20]

“I can say at proof, can you clear all of the comments here? And because the agent can do anything the user can do, even if I haven’t built this feature explicitly, it just knows how to do it. And you’ll watch the comments disappear in a second.” [00:28:01 - 00:28:13]

“It’s all because of, he’s so smart, but also his workflow is really incredible. So he’s going to talk about how he’s building an iOS app and all the stuff he’s learned about building an iOS for monologue.” [00:08:08 - 00:08:20] (Speaking about Naveen’s one-person development competing with 30-50 person companies)

← Back to Index Ben Tossell →