Video Summary - How I code with AI changed a lot

Summary (technological concepts, tools, features, and workflow insights)

Workflow shift (agentic coding approach changed): The speaker says their earlier workflow—using Cursor + “plan mode” with Opus-like models, treating plans as the primary output—no longer matches how they build today. Their current workflow emphasizes:
- agentic tools
- prompt steering
- context management
- remote execution
- reliable verification
Sponsor/Product: Clerk (auth + billing for many apps)
- Pain point: authentication + billing becomes expensive and frictionful across many projects.
- Key detail: Clerk offers “unlimited apps on paid plan and free plan”, so multiple projects don’t multiply cost.
- Billing setup: uses a Stripe-compatible billing system (“best Stripe implementation”), including:
  - pricing table components
  - user-based billing data via a user component
- Benefits mentioned: setup is much easier than using Stripe directly, with comparable cost to Stripe when used alone.
Core project experience driving changes: “Lakebed / Span”
- The speaker built an ambitious full-stack framework/runtime + backend + database + cloud runtime aimed at making it easier to build agentic applications.
- They tested many agent/coding tools while building it (e.g., Cursor, CodeX app, T3 Code, Cloud Code, open-source models).

Models used (and why)

They mostly use GPT-5.5.
They’ve mostly stopped using Claude models, using them only occasionally (e.g., generating a quick landing page).
They discuss plan-based inference/usage limits:
- On a $200/month plan, GPT-5.5 usage is effectively “unlimited-ish.”
- Weekly usage limits still exist, but are generous; faster or more feature-heavy harness use can hit limits sooner on cheaper plans.
They mention Composer 2.5 positively, but still prefer GPT-5.5.

Harnesses / agent execution tools (what they are + what they prefer)

Harness definition

A harness is the tooling/runtime that lets an agent operate on your computer (edit code, run commands, use CLIs, etc.). It’s often delivered as a CLI or SDK.

Speaker preferences

They default to the CodeX harness / Codeex.
They like that CodeX keeps its CLI minimal/boring, while the richer features live in the CodeX app, and that harness behavior still transfers across uses elsewhere.

Clarifying products: T3 Code vs T3 Chat

T3 Code is not a harness.
T3 Chat: chat with AI agents (ChatGPT-style).
T3 Code: an app for managing/controlling other AI harnesses (similar to orchestration tools like “Conductor” / CodeX app style).
They say T3 Code is open source and stable/reliable for remote workflows.

App/IDE workflow comparison (especially remote)

CodeX app vs remote execution issues

They tried remote control via CodeX desktop/mobile:

Mobile integration: works well.
Desktop remote: had serious issues, including:
- model picker sometimes disappeared, freezing remote control until restarting/reconnecting
- slow/buggy prompt history rendering
- terminal interaction problems (sticky keys/typing delays, occasional image paste failure)
- long delays (about 30 seconds to 2 minutes)
Conclusion: they weren’t happy with CodeX desktop remote; mobile was better.

T3 Code remote as the preferred solution

They describe T3 Code remote as:

stable
reliable with images/paste
terminal typing behaves like actual SSH (full speed)

They discuss two remote modes:

Built-in app remote
Remote hosted mode (example: running via a hosting provider like “Helium”)

They also cite a strong example user (“Jack”) using:

Android tablet + remote T3 Code server on Replet

Networking: Tailscale / custom SSH

They recommend Tailscale to connect to devices across networks without exposing them to the public internet.
They note T3 Code supports:
- Tailscale-style remote connection setup
- UI for storing SSH passwords
- custom SSH connections (possible, with a note that CodeX may be rough)

Image and terminal limitations (why desktop apps matter)

They strongly criticize “SSH terminal + agent coding” workflows because of:

tmux/screen and keybinding complexity
image pasting often not working over SSH
lots of workaround pain (e.g., Raycast-like uploads)

Their stance: use a good desktop app rather than assuming terminals are the only solution, especially because they rely on images in prompts—said to be roughly 1/3 to 1/2 of prompts.

Context management: prompt strategy that improves reliability

They emphasize: context is the name of the game.

Reliable techniques include:

Have the agent explore relevant codebases (clone repos and use local implementations as reference, not just descriptions).
Provide specific examples rather than over-explaining.
Use short prompts (often ~2 sentences or a few list items), focusing on goals rather than implementation minutiae.

“Plan” vs steering (their view)

They say they don’t use “plan mode” in the old sense.
Instead they prefer natural back-and-forth, where the model writes/tests/edits directly.
They still like planning, but not with rigid plan-mode constraints.

Agent MD steering document (“agents MD”)

They say the biggest improvement was writing a custom agents MD “like a letter” that:

defines how the agent should think
reduces weird assumptions/questions
avoids low-signal constraints (like overly rigid instructions about file paths)

They report:

the agents MD was written by hand (not generated)
after adding it, agent behavior improved quickly

Template for how they run threads/tasks

They run many threads (in CodeX/T3 Code), but not in parallel.
They create new threads frequently because:
- older chat context can bias the model toward prior tasks
- they want a clean steering context for each concern (e.g., env vars vs rate limits vs domains)

They argue that agents can handle codebase/context exploration quickly enough that repeated exploration isn’t a major cost.

Verification tooling (agent success criteria)

They stress giving agents tools to verify their work, including:

CLI commands
test suites
browser “computer use” to confirm UI behavior
deployment + smoke testing

They call out CodeX “computer use” plugins as especially useful, and note that setup in CodeX can still be workable via T3 Code.

PR workflow and review automation

Their PR flow generally involves:

Asking the model for thoughts when complexity is uncertain
Choosing to use the current worktree or spawn a new one
Using PRs when second opinions matter (e.g., security/hosting changes)
Using agent/tools like:
- CodeRabbit
- Macroscope
- Graphile to catch issues, then looping until resolved
Automating “run checks until no feedback” to avoid repetitive copy/paste

They also warn about PR bloat:

one-click PR features can create many stale/unmerged PRs
they mention many open PRs in their T3 Code repo (numbers referenced)

Sponsor/ads mentioned besides Clerk

DNSimple (referred to as “Dian Simple” in subtitles)
- They praise DNSimple’s SDK/CLI for managing domains and forwarding.
- Claimed benefit: APIs are otherwise painful; an agent-friendly CLI helps with DNS debugging.
- Includes help commands so agents can discover how to use the CLI.

Key takeaways emphasized by the speaker

Keep workflows simple; don’t over-engineer.
Use the model through good conversation + steering context, not excessive prompt scaffolding.
Read and steer the model’s written outputs (plans/agents MD matter; don’t only read code).
Prefer desktop/remote-capable apps over SSH terminal workflows—especially since prompts often use images.
Make agents reliable via:
- good context/codebase references
- short goal-oriented prompts
- steering documents (agents MD)
- strong verification loops (tests, CLI checks, deployment checks, browser automation)

Main speakers / sources

Main speaker: the YouTube creator (first-person throughout), explicitly referencing building T3 Code / Lakebed / Span and their workflow.
Product sources mentioned:
- Clerk
- DNSimple
Tool sources mentioned: CodeX (Codeex/CodeX app), T3 Code, Cursor, Cloud Code, Conductor, Tailscale, Replet, plus review/check tools like CodeRabbit, macroscope, graphile.