Was ich nach 900 Stunden KI-Coding komplett anders mache

Technological concepts & workflow (core of the video)

The speaker argues that AI agents fail when run “blindly”. The solution is a disciplined, multi-phase workflow that includes:

• explicit context management
• shared requirements
• testing loops
• cleanup/refactoring

Key workflow problem they describe (analysis)

Without a workflow, an agent may:

• rebuild already working parts
• loop on bugs instead of converging
• create more work than it removes

Their solution reduces wasted debugging and iteration time.

---

The step-by-step “8 phases” framework (tutorial/guide)

They claim to provide a complete step-by-step workflow, using Markdown documents as handoff artifacts between phases, plus context resets to avoid losing structure.

1) Brainstorming phase

They start with an AI “skill” called Brainstorm (found in their GitHub repository).

• Run it by typing “Brainstorm” or prompting the agent (e.g., “Let’s talk about a topic”).
• Benefits:
  • multiple brainstorming methodologies
  • outputs saved as a Markdown file for later phases

They emphasize a context reset between phases, while still retaining prior insights through saved docs.

2) “Dump zone” / context-window management

They introduce a “dump zone” concept:

• the model has a “smart zone” (effective token range)
• and a larger “stupid zone” (less reliable behavior)

They show how to check token usage:

• In OpenAI Codex: inspect “context window” and tokens consumed
  • example: ~17k used; smart zone roughly 0–100k tokens
• In Cloud Code (Anthropic): query context
  • example: ~20k tokens

Takeaway:

• save phase outputs to Markdown
• reset context between phases
  • don’t restart from scratch entirely
  • avoid wasting tokens in low-quality zones

3) Solo phase (shared understanding within a team)

They introduce a “shared understanding” requirement:

• prevent misaligned interpretation (e.g., the “six vs nine” problem)

They show a skill: “Grill Me” by Mad Pocock.

• The AI intensely interviews the user/team about the topic.
• This prevents the agent from starting implementation based on shallow assumptions.

At the end of the phase, outcomes are saved to Markdown again.

4) Planning phase (horizontal vs vertical slicing)

They propose breaking the big document into implementable pieces using vertical slicing.

• Horizontal slicing (build frontend → logic → data)
  • long time before anything testable
  • slow feedback loops
  • weak validation
• Vertical slicing (build one feature end-to-end)
  • e.g., a “Reserve” button includes UI + logic + data behavior
  • then next slices: cancel flow, email confirmation, etc.

Why it matters for AI agents:

• AI often defaults to horizontal slicing unless prompted otherwise

Prompt technique:

• review the Markdown
• ask questions until shared understanding exists
• choose the next vertical slice to tackle

UI guidance:

• sketch/record a rough UI and give it to the agent.

Testing strategy:

• explicitly ask the agent to propose how it will test the vertical slice
• if the “test plan” is just cosmetic questions, request a plan that ensures completion

5) Implementation phase

• reset context again (e.g., “new” / “clear”)
• implement the plan
• watch context limits:
  • try not to exceed ~100k context
• compaction quality varies by agent/model:
  • Codex: compaction seems “good”
  • Cloud Code: compaction seems poor (behavior varies across token ranges)

6) Testing phase (short feedback loops)

They stress rapid iterations:

• get feedback on whether the software:
  • actually works
  • feels usable

Target usability problems such as:

• awkward workflows
• too many buttons
• too many input fields
• too much text

They also rely on earlier test-aligned instructions so functionality is already partially checked.

7) Recap phase (product understanding)

They warn against “feature treadmill” behavior:

• if you skip recap, you lose awareness and decision-making

Recap asks the agent:

• How does what we built work?
• optionally: draw it in a diagram

Purpose:

• keep human control of direction and product coherence.

8) Refactoring phase (“Reforge”)

• AI tends to add complicated code

• they urge proactive cleanup:

  • ask for the smallest refactoring step that improves structure
  • ensure a new developer can understand it without mental leaps
  • preserve behavior while improving code organization

They provide a “chaos accumulation” rationale:

• if you delay cleanup, AI copies the existing mess onto a bad foundation.

9) Commit / pull request phase (cleanup of artifacts)

They recommend:

• small commits: “commit code atomically” with minimal Git diffs
• delete Markdown artifacts from previous phases:
  • once code is truth, keep the repo clean
  • otherwise future iterations may follow outdated docs

Finally, push to master / PR depending on solo vs team work.

---

Handling hard bugs (guide addition)

When repeated iterations hit difficult bugs:

• the AI should use a self-verification method, developed collaboratively

They use a loop where the AI:

• describes the bug situation
• works with the user to define how to verify the fix
• tests repeatedly until the solution converges

For less difficult problems:

• start a new agent/chat
• provide:
  • the copied problem description
  • what was tried so far

They say this “usually is enough” to reach the goal.

---

Product/competition outcome & review angle

The tool/project is called “Honest Product Tester.”

Concept:

• test a website using six different AI agents
• each agent represents a different user persona:
  • stressed manager
  • skeptical student
  • techie trying to break things
• each agent has its own browser session
• agents return reviews and feedback

Built using: P Agent by Mario Zechner (they mention a separate video about it)

Hackathon results:

• they won 5th place out of ~45 teams at the OpenAI Hackerton
• prize included two ChatGPT Pro subscriptions (~€5000 total)
• plus a story about local food from company Centry

---

Main speakers/sources (as stated)

• Main speaker: the video author (speaker not named in subtitles), and their wife Jana (mentioned as having her own channel)

Skills / sources mentioned

• Brainstorm Skill (in the speaker’s GitHub repository)
• “Grill Me” Skill by Mad Pocock
• P Agent by Mario Zechner
• Honest Product Tester participants:
  • “six different AI agents” (personas)
  • hackathon company Centry

Moderator mentioned

• Alex (day moderator)