KI programmiert Apps, aber es wird immer schwieriger

Overview

The video is a “difficulty levels” test of whether AI (specifically Horizons / Syn Manager products) can replace software developers by going from simple web apps to complex platforms.

Core idea / premise

• The host, Niklas (a former professional software developer), benchmarks AI-assisted programming across 7 levels (plus a “3.5” midpoint).
• Claim progression:
  • Levels 1–3.5: AI can generate working apps with little to no developer assistance.
  • Level 4 (Twitter clone): AI can sketch/implement key social-network behaviors, but not the full robustness of real production systems.
  • Levels 5–7: extremely hard due to:
    • distributed systems
    • offline/local-first correctness
    • collaboration/CRDTs
    • large-scale feed ranking/analytics

Level-by-level findings (tech concepts + what worked/failed)

Level 1: Static website (passed)

• Prompting can generate a complete homepage quickly.
• The output includes:
  • a basic “document-like” site structure
  • minor UI interactions (e.g., hover)
• Emphasis: no “real backend”—just frontend/static behavior.

Level 2: Simple interactive app / “Wordle” (passed, with limitations)

• With a minimal prompt (“Implement Wordle”), AI produced a working game.
• Observed limitation:
  • “Statistics” persist only within a single browser session (cookie/session-like memory).
  • In a private window after reload, stats are empty.
• Key architecture note:
  • No backend authentication/persistence in this level.

Level 3: CRUD apps with backend + database (passed)

• Level 3 adds a real backend for Create/Read/Update/Delete.
• Horizons is said to support backend and user registration.
• Example shown:
  • a Schengen/visa/habit-style tracker (“Shangentracker.de”) where login works and data persists.
• Conclusion: AI handles “full-stack CRUD” well enough that a developer may not be required for typical CRUD apps.

Level 3.5: “CRUD + AI features” (flashcard generation)

• AI in CRUD apps is treated as “3.5” (not a new architecture layer, more of a capability upgrade).
• Example: “Build a Flash app” that:
  • uploads lecture slides/PDF
  • uses AI to create flashcards
  • uses spaced repetition/study interface
• Implementation detail:
  • The host mainly debugged by copying browser console errors (F12) into the chat.
• Outcome: a functional “map/flashcard-like” study tool (AI-generated index cards from slides).

Level 4: Twitter-like social platform (partial success / constrained)

• AI can generate a Twitter clone’s core behaviors:
  • user/account creation
  • posting tweets
  • posting comments
  • basic profile/privacy behavior (e.g., “Privacy First” behavior)
• Observed issue:
  • permissions/visibility relationships are not fully correct (e.g., comment visibility vs profile existence/private profiles).
• Host’s argument for feasibility:
  • Level 4 is possible because AI can handle graph-like relationships (users ↔ tweets ↔ comments + access control).
• Warning:
  • not equivalent to real Twitter due to complex authorization, data integrity, and edge cases.

Level 5: “Local-first” task manager with offline sync + time zones (attempt failed)

• The host targets a high bar: a “Task manager on par with To-Doist/Linear/Superhuman” including:
  • local-first multi-device
  • offline usage
  • calendar integration
  • time zone logic
• AI initially claims offline-first is supported via:
  • Local storage / IndexedDB / Service Worker
  • a sync engine + conflict resolution (mentions Sync Manager)
• Reality check:
  • the demo does not actually work offline as promised (saving tasks fails offline).
• Code inspection notes:
  • data is created online first, then a local copy exists later—not true Local First (i.e., not source-of-truth local DB).
• Key technical critique:
  • “hallucination” / false confidence is still a major issue.
• Host’s conclusion:
  • from Level 5 onward, AI can’t reliably know whether its implementation matches the required correctness constraints.

Level 6: Google Docs-style real-time collaborative editing (conceptual barrier)

• Level 6 requires handling:
  • real-time multi-user collaboration
  • conflict resolution (CRDTs: Conflict-Free Replicated Data Types)
  • correct merging/deletion semantics under concurrency
• Demonstration (“Collab Dogs”):
  • creating a document works and multiple editors can appear active
  • opening two browsers and refreshing causes edits to disappear
• Emphasis:
  • merging semantics and conflict resolution remain hard without serious engineering.

Level 7: YouTube-level scale (feeds + distributed counters + ranking)

• The video argues Level 7 includes:
  • video storage/distribution at scale
  • recommendation/feed ranking systems
  • distributed analytics like accurate view counts
• Example critique:
  • incrementing a view counter (“+1”) across distributed systems without errors is extremely complex.
• Conclusion:
  • AI can create “interfaces that look like YouTube,” but truly recreating YouTube’s architecture is far beyond prompt-only generation.

Overall conclusions / takeaways

• AI can replace or massively reduce developer work for:
  • static sites
  • Wordle-like interactivity
  • CRUD + backend + auth
  • AI-powered add-ons (flashcards/study tools), with some debugging
• AI struggles with:
  • offline-first correctness (Level 5)
  • real-time collaborative editing conflict handling (Level 6)
  • distributed scale analytics and ranking (Level 7)
• Main warning:
  • from Level 5+, the difficulty isn’t only coding—it’s verifiable system correctness under distributed/disconnected/concurrent conditions.

Product / tool mentions

• Horizons: used to generate apps from prompts.
• Syn Manager / Sync Manager: mentioned as a “pre-loop” for syncing; the host argues it wasn’t sufficient for promised Local First offline behavior.
• Discount mention:
  • “Horizons Link” with code Nick (10% off).

Main speakers / sources (end)

• Speaker: Niklas (degree in computer science; worked as a professional software developer).
• Source/product being tested: Horizons (and its Sync Manager/Syn Manager components).