i use AI wrong (and you should too)

Lars Bate’s Core Idea: “Delegation,” Not Agent Hype

Lars Bate argues that he “uses AI wrong” only in the sense that he doesn’t follow common “AI agent / software factory” narratives. Instead, he frames foundation models as a delegation layer: you start with your intent, and the model handles the how—similar to delegating work to another developer rather than abstracting away all implementation details.

Core “delegation” criteria (when he delegates work to a model)

He says he delegates tasks into four buckets:

• Write
• Refactor
• Research
• Reinforcement (can take the form of a tutorial)

Tooling He Uses

1) Zed (IDE / code editor)

• His main editor after using VS Code variants, Cursor (which he felt moved toward an “agent-first” chat UI), and before that Sublime Text.
• He values staying in code mode: seeing directories/files while still using chat threads for delegated tasks.
• He uses the model as an interactive documentation / tutorial generator inside the existing codebase—more transformative to him than pure code generation.
• Common workflow pattern:
  1. Ask for code
  2. Paste into files
  3. Do a quick sanity check
  4. Only later go deeper

2) Open Code (model provider)

• Chosen for an open-weight model focus (though some GPT models are also available).
• He’s on a Go plan ($10/month).
• Main models he relies on:
  • GLM variants
  • models named Kimmy and Mimo (including “Mimo 2.5 Pro” later)
• He emphasizes his requests are typically “isolated and surgical,” not long-running “huge sweeping plans,” which he believes suits open-weight models well.
• He notes cost effectiveness: he uses pay-as-you-go credits and reports still having credit remaining despite heavy use.

Examples

Example 1: Delegating data / formula extraction (solar calculator)

• Scenario: Building a solar calculator where formulas currently live in an Excel spreadsheet, and needs to be moved into PHP.
• He delegates the task to Mimo 2.5 Pro in Zed.
• Model action:
  • referenced the spreadsheet (by writing Python to view it)
  • extracted the needed calculation functions
  • provided verification scripts to confirm spreadsheet values match model outputs
• Lesson: The model generated a good starting point, but didn’t automatically place code into the correct file. He describes the model as pedantic and says he must be explicit about where to put things.
• What he liked: It produced both the implementation pieces and validation to check correctness.

Example 2: Refactoring UI behavior in a “brownfield” app (Wallaby)

• He uses an existing platform (Wallaby, wallaby.me) and updates a message-board feature.
• Problem: Removing a message used a browser alert (unprofessional).
• Approach: In Zed, he tells the model exactly where to change code (in the message instance / message entry areas), providing context to reduce wandering/token waste.
• Output: The model updated the UI to use a custom modal component (wrapped modal with animation props).
• Testing: He reloads the page and confirms behavior (off-click handling, escape key handling, etc.).
• Then he manually makes minor UI/format tweaks (e.g., line breaks / Tailwind text balance) rather than asking the model to handle every aesthetic cleanup.

Example 3: Interactive learning via a dynamic “course outline” (Laravel)

• He’s building a Laravel app for the “Confident Coding” site and wanted a structured learning path.
• He used models to generate:
  • a learning plan
  • a course/outline
• Key concept: Using models this way requires balancing roles—he’s both tutor and student, so prompts must be specific enough to teach without becoming misaligned.
• Workflow:
  • the model asks questions
  • checks answers
  • clarifies when needed
  • instructs where to write code
• He emphasizes this is not about code generation—it’s self-education and contextual stepping through a real project with an embedded agent-like tutor.

Overall Takeaway

By conventional “AI hype cycle” standards, he claims he’s using AI “wrong,” but argues his priorities are different: learning, growth, staying aware of code changes, and delegating targeted tasks.

He credits code generation with reducing typing, but insists that core logic/strategy/problem-solving/critical thinking still matter.

Main speaker / source

• Lars Bate (speaker, creator; “Lars Bate here again.”)