Skip to content

By playing, you agree to uListen's Terms and Privacy Policy and YouTube's Terms of Service.

Aakash GuptaAakash Gupta

Aakash suhao podcast

Shuhao Zhang, co-founder and CPO of TinyFish, opens his real GitHub to show the agent pipeline that lets anyone there ship to production. Then he shows the ops agent he thinks will set teams apart.

SuhaoguestAakash Guptahost
Nov 19, 20261h 2mWatch on YouTube

Summaries, chapters, transcripts, and FAQs on this page are made by uListen, not YouTube.

Great conversations run long. Their best ideas don't have to.

uListen is free on iPhone, iPad, Android, Chrome, and Claude.

See how

CHAPTERS

Jump to publisher timestamps

Chapter summaries

  1. Why human code review becomes the bottleneck in an agent-driven world

    Suhao frames the core problem: as coding agents generate massive amounts of code instantly, traditional human review becomes the slowest step. He also sets an ambitious direction—systems that let non-engineers ship to production.

    • •Coding agents can generate thousands to tens of thousands of lines of code extremely quickly
    • •Human reviewers become the throughput bottleneck
    • •The goal is enabling anyone (not just engineers) to ship to production
    • •The episode will focus on the full build-to-production lifecycle with agents
  2. Tinyfish’s growth context and the promise of an end-to-end agentic build system

    Aakash introduces Tinyfish’s rapid user growth and fundraising, then previews what makes their approach distinctive. He describes an end-to-end system—PRD through measurement—where agents play a central role and many people can ship.

    • •Aakash cites Tinyfish’s rapid user growth milestones and funding
    • •He attributes a big part of speed to a system that lets anyone ship to production
    • •He describes investment across PRDs, coding agents, code review, and CI/CD
    • •Suhao is positioned as walking through the lifecycle and tools used
  3. Suhao’s day-to-day CloudCode workflow: dev server, tmux, and multi-project execution

    Suhao demonstrates his CloudCode setup and explains how he works from a persistent remote environment. He shows how he keeps multiple projects running, using a terminal session that stays alive in the cloud across devices.

    • •CloudCode setup uses a cloud dev server and a persistent terminal session
    • •tmux enables resuming the same terminal session from mobile/browser
    • •A full cloud instance allows installing tools as needed and keeping work running
    • •He manages multiple concurrent projects, each representing a feature or product effort
  4. Demystifying core environments and tools: dev server, sandbox, and why not CloudCode Web

    Aakash asks for a plain-language explanation of the setup. Suhao defines dev servers and sandbox environments, explains tmux, and contrasts his self-managed instance with CloudCode Web’s convenience and limitations.

    • •Dev server: remote compute so workloads run without keeping a laptop on
    • •Sandbox: pre-production environment close to production but without real user data
    • •tmux: streams a terminal session securely over the network
    • •Suhao prefers full control of his own instance (e.g., VPN setup) versus CloudCode Web
  5. Using artifacts to align with agents: planning, clarifying requirements, and review loops

    Suhao explains how he separates routine agent activity from high-value communication and alignment. He uses Claude artifacts for plans, recommendations, and inline feedback so the agent can incorporate decisions and continue.

    • •Valuable communication (requirements clarification and feedback) happens outside the raw chat log
    • •Claude artifacts are used for the agent’s plan and for inline human review
    • •Artifacts become the place to respond and drive the agent’s next steps
    • •Suhao signals he’s actively experimenting with these workflows and wants feedback
  6. AI code review at scale: CodeRabbit auto-approval, escalation, and avoiding infinite nitpicks

    Suhao describes how Tinyfish preserves strong code review culture while removing human review as a bottleneck. He shows CodeRabbit reviewing PRs, requesting changes, iterating with an agent, escalating high-risk items to humans, and auto-merging low-risk PRs.

    • •Tinyfish treats code review as essential, but agent-generated code volume overwhelms humans
    • •CodeRabbit can approve, reject, and request changes; agents iterate until resolved
    • •High-risk issues trigger escalation to the right engineers for human judgment
    • •Low-risk PRs can be auto-approved and auto-merged to keep throughput high
    • •Aakash highlights minimizing wasteful back-and-forth (token burn)
  7. The “constitution” and knowledge base: codifying standards and assigning ownership

    Suhao explains how CodeRabbit review quality depends on codified conventions and review strictness. He describes building a shared knowledge base to prevent unproductive reviewer-agent loops and explains how a senior engineering owner drives AI productivity experiments.

    • •A “constitution” captures conventions, standards, and how strict reviews should be
    • •The goal is catching what matters without nitpicky infinite loops
    • •A knowledge base/playbook supports both coding agents and review agents
    • •Aakash asks about ownership; Suhao says a senior engineer (head of engineering) leads AI productivity work with team input
  8. Replicable foundations: templates, Terraform, and standardizing infra + CI/CD across projects

    Suhao outlines how others can replicate the system by starting with a deployable template. He walks through using Terraform-based infrastructure-as-code to standardize sandbox/production environments, networking/access patterns, containers, tests, and deployment paths.

    • •Start with a template so teams can replicate proven structure
    • •Terraform is used for infrastructure-as-code and CI/CD consistency
    • •Separate infra definitions for sandbox and production to reduce drift
    • •Standardization prevents each new project from inventing its own deployment approach
    • •Terraform enables reviewable infra changes that propagate to the cloud after merge
  9. Org-wide agent guardrails and portability: rules, best practices, and multiple agent preferences

    Aakash asks what lives in the shared agent configuration area. Suhao describes organization-level best practices and guardrails that shape agent behavior, plus flexibility to support different coding agents and tools to transform skills across them.

    • •A shared area contains best practices and rules/guardrails agents must follow
    • •The intent is consistent “coding agent style” across the organization
    • •Engineers may prefer different coding agents; skills can be migrated
    • •A tool can transform skills across agents to reduce lock-in
  10. From idea to PRD to implementation: front-loading decisions so agents can run for hours

    Suhao explains how he prompts features using simple language, including voice mode, and pushes agents to challenge ideas and propose alternatives. He generates layered documentation (PRD, engineering plan, implementation plan), reviews key decisions, then lets agents implement for long stretches without constant interruptions.

    • •Feature work begins with brainstorming and research (market/competition) with an agent
    • •He encourages the agent to challenge assumptions and run small experiments
    • •Outputs include many evolving documents: PRD, engineering plan, implementation plan, API and architecture designs
    • •He asks the agent to surface 10–15 decisions needing attention while delegating low-risk decisions
    • •Front-loaded clarity reduces frequent agent questions and helps parallelize multiple long-running build sessions
  11. The next frontier: agents operating production via observability (logs, metrics, traces)

    Suhao argues that building with agents will become a commodity, and differentiation will come from agents operating services in production. He introduces an observability stack and explains how agents can continuously consume telemetry data to detect issues earlier than humans.

    • •Operating in production is positioned as the key differentiator in speed and reliability
    • •Observability stack collects logs, metrics, and traces from production systems
    • •Agents are described as better suited to continuously ingest large volumes of telemetry
    • •Goal: detect bottlenecks and business logic issues before alarms or outages occur
  12. Explaining logs vs metrics vs traces—and what problems observability helps uncover

    Aakash asks for a clear distinction among logs, metrics, and traces. Suhao defines each, explains how they work together to diagnose failures and performance bottlenecks, and emphasizes the sheer volume of production data that can reveal improvement opportunities.

    • •Logs: verbose event records across a request/user lifecycle, useful for debugging and replaying what happened
    • •Metrics: numeric signals like request volume, CPU/memory, and latency distributions
    • •Traces: end-to-end view of a request across multiple services to locate bottlenecks
    • •Used together, they help pinpoint failures, performance issues, and optimization targets
  13. AI Ops loop in practice: detect issue → open ticket → code fix → AI review → deploy

    Suhao walks through an example where an ops agent identifies an error classification issue from logs/traces, creates a Linear ticket, and generates a PR. CodeRabbit reviews it, auto-approves low-risk changes, and CI/CD deploys to staging—creating a continuous, automated remediation cycle.

    • •Agents need authenticated access to observability tools (e.g., via firewall/VPN on the dev server)
    • •An ops agent detects issues by mining production telemetry continuously
    • •Workflow mirrors engineers: open a Linear ticket, document findings, then implement a fix
    • •The agent pushes a PR to GitHub; CodeRabbit can approve low-risk fixes automatically
    • •Merge triggers automated deployment to staging through CI/CD
  14. Safety mechanisms and rollout strategy: partial rollouts, gated releases, and agent-checked results

    Aakash probes how to ship agent-produced changes safely. Suhao advocates partial rollouts (e.g., 1%) as a last defense against catastrophic changes and argues agents make this feasible by monitoring rollout performance without requiring humans to manually inspect every release.

    • •Partial/gradual rollouts help validate changes before full production impact
    • •Historically costly because humans had to monitor rollout stats and judge regressions
    • •Agents can monitor rollouts and make decisions more continuously
    • •Suhao argues the system can be safer and more efficient with agent automation
  15. What to build first, common pitfalls, and why speed now changes ‘build right’ thinking

    Suhao explains that the critical investment is the organizational “machinery” to produce, deploy, and operate—more than any single product. He shares a key mistake (overthinking and delaying), discusses how speed doesn’t have to mean low quality, and argues that fast iteration with real user feedback is now more important because building is cheaper.

    • •Focus shifts from individual products to the capability/muscle of shipping and operating with agents
    • •Biggest scar tissue: overthinking and delaying because of fear of what could go wrong
    • •Building fast is framed as compatible with production-grade quality if the machinery is strong
    • •He argues past “build the right thing” processes were driven by high build cost; now fast user feedback matters more
    • •Alignment and drift are managed through layered documents and detailed planning to reduce assumptions
  16. Roles in the agentic future, growth implications, and building for agents as users

    Suhao describes how PMs, engineers, and agents may divide responsibilities: humans dogfood and set direction while agents handle continuous improvement and maintenance. He connects this approach to Tinyfish’s growth by emphasizing “hill climbing in production,” handling diverse edge cases, and treating agents as a new class of extremely picky users.

    • •Humans still need to experience the product and provide feedback (e.g., UI feel, dogfooding)
    • •Test automation is explained across unit, end-to-end, and load testing; agents can help create tests
    • •PMs shouldn’t be intimidated but need an engineering partner and strong company machinery
    • •Agents can reduce ‘hostage’ maintenance by continuously improving what’s shipped
    • •Suhao claims agents will be a new type of user and describes them as extremely discerning evaluators
    • •He attributes competitive advantage to continuous production improvement that handles diverse, hard-to-predict edge cases

Publisher timestamps

  1. 1:32How TinyFish lets anyone ship to production
  2. 6:52Ads
  3. 8:44From the agent's plan to an AI-reviewed PR
  4. 14:54Start every project from a template
  5. 18:26From idea to PRD to a 20-hour build
  6. 23:52Why running production is the next frontier
  7. 24:46Ads
  8. 28:05The ops agent that fixes production
  9. 40:41The biggest mistake: thinking too much
  10. 43:24Building fast doesn't mean shipping slop
  11. 51:13How technical a PM needs to be
  12. 57:12Agents as users and the cost of not building

Get more out of YouTube videos.

Read along on your phone, search it beside the video, or ask your favorite AI app what was said.