I Let a Chinese AI Build My Entire App?

Core project + problem

• The speaker, an experienced software engineer, wanted a simple “all links in one place” website to address limitations of social media profiles.
• Most social platforms only show one visible profile link, even when users have multiple links they want to share.
• SaaS tools (e.g., Linktree, Beacons, Squarespace) weren’t truly “free” because:
  • Branding appears on the page
  • Upgrade pressure via emails and upsells
  • For example, Squarespace requires a custom domain even if it offers a “free” page

Approach: build the link-page generator using an open(-weight) AI model

• The speaker decided to build their own SaaS link-page generator using Kimi K3, described as an open-source boundary model with open weights.
• Motivation: reduce dependency risk on a single closed provider, later arguing that pricing/subsidy behavior is non-sustainable.

Tooling / architecture for development (tech concepts)

LLM access

• Used OpenRouter as a cloud “marketplace/reseller” for hosting the model.
• Chose a US-based reseller and avoided paying the model creator directly.

Agent harness concept

• An agent harness manages the model’s context window, described as “short-term memory” of ~1 million tokens.
• It uses memory markdown files:
  • Global memory
  • Project-specific memory
• When the context fills, it can summarize/compact or reset context while preserving memory.

Tool use via MCP

• MCP (Model Context Protocol) allows the agent to call external tools (programs/APIs), such as:
  • DB reads
  • Web browsing
  • API calls
• MCP is framed as a common protocol to make tools reusable across agent environments.

Skills vs tools

• Tools: executable external capabilities.
• Skills: reusable instruction bundles (stored as markdown).
• Warning: downloaded skills can be malicious, since an LLM may treat all instruction text as equally valid.
• The speaker prefers creating their own skills.

Agent environment used for code generation/testing

• Multiple agent environments exist, including company-specific ones (e.g., “Claude code”, “Kimi code”, OpenAI “Codex”).
• Open-source agent environments were also mentioned (e.g., Open Code, Pi Code, Hermes).
• For this work, the speaker used “Visual Studio Code Agent” as a generic testing environment to avoid biasing results.

How the build workflow was executed (guide/tutorial aspects)

1. Generate a technical design

   • The model produced a technical specification for the link-page generator.
   • The design prompt emphasized:
     • Self-scaling
     • Highly maintainable by a single developer
     • Asking the model to ask the user questions during design
   • Observed behavior: Kimi asked more questions than the speaker’s earlier experience with “Claude Fable.”

2. Review/adjust the proposed architecture

   • Two flagged issues:
     • Storing analytics per bio page in the same DB as the main app (traffic spikes could cause DB write contention/performance issues)
     • Using “standard PostgreSQL” instead of managed DBaaS (maintenance burden)
   • Finalized tech stack:
     • Front-end: React + Tailwind
     • Middleware: Next.js
     • Back-end / DB: Convex
     • Analytics: Google Analytics
     • Auth: Clerk
     • Payments/subscriptions: Stripe
   • Design phase duration: ~20 minutes

3. Implement code in one pass (no sub-agents)

   • A typical pattern is using “sub-agents” for parallel phases, but the speaker chose not to.
   • The prompt required phased implementation with:
     • Unit tests for everything
     • End-to-end tests for critical user flows
     • Iterative test/fix loops until passing
   • Build time: ~over an hour
   • Issue encountered: the agent/model sometimes entered a deadlock-like state (token consumption without progress), requiring intervention and restart.

4. Code validation / review automation

   • Manual review was impractical:
     • A human can only review ~500 lines/day with high quality
     • The model generated thousands of lines
   • The speaker used a code review function that:
     • Automatically found defects
     • Classified defects by severity
     • Suggested fixes
     • Produced a “map” to prioritize human review
   • Review took several hours.

5. Local testing + bug fixing

   • Minor styling issues; core functionality was mostly accurate.
   • Found a hook order race condition requiring additional fixes.
   • Also noted a potentially concerning behavior: the model sometimes randomly requested production deployment keys; the speaker refused and redirected.

6. Deployment

   • Deployment to Vercel was straightforward.
   • Total time from idea to production: < 2 days

Review/assessment of Kimi K3 vs Claude “Fable”

Positive

• “Very capable” at software engineering; roughly comparable to the speaker’s “Claude” benchmark.
• Generated a working app quickly with strong overall correctness.

Concerns

• Less polished in:
  • System design
  • Bug fixing
• Possible cause speculated: differences in training/reinforcement learning between providers.
• Noted occasional integration problems between the model and the agent environment (crashes/hangs).
• Random requests for sensitive information (deployment keys) meant user control was necessary.

Cost analysis & dependency risk argument (key analysis)

• Token usage to build the app: tens of millions of tokens
• Cost via OpenRouter reseller: >$50
• Estimated cost using “Claude” with similar token usage: >$200
• The speaker argues this implies Anthropic subsidizes token pricing:
  • If true cost were ~5–10x what subscribers pay, subsidy would be non-sustainable.
• Risk conclusion:
  • If a workflow depends entirely on one closed provider, you’re vulnerable if pricing changes.
• Therefore:
  • Open(-weight) models like Kimi provide alternatives and reduce “tech-feudal dependency” risk.

Main speakers/sources

• Main speaker: The video’s narrator (unemployed; formerly a major-tech software engineer; ~25 years experience) who built the link-page SaaS with Kimi.
• Primary AI systems referenced:
  • Kimi K3 (via OpenRouter)
  • Comparisons to Claude (“Fable/Claude Fable”)
  • Related ecosystem: “Claude code”
• Agent environment referenced: Visual Studio Code Agent