I talked to 50 people building with AI. It’s a mess.

Tech concepts & recommended “agentic development” workflow (from ~50 1:1 builders)

The speaker argues that many AI builders are using 2025-era agent workflows that no longer fit current frontier model behavior. They recommend simplifying processes and relying on modern models (named throughout) like Astra, Opus 5.5, and Fable.

1) Stop “over-instructing” agents with old guardrails

• Earlier agents needed extensive negative instructions in files like agents.md / claw.md to prevent bad behavior.
• With current models, the speaker recommends:
  • Delete old instruction files
  • Start from scratch
  • Only re-add constraints if behavior misfires (expected to be rare).

2) Don’t build a “factory” / orchestration system for agents

• Common mistake: creating elaborate multi-agent “systems” with orchestrators, tabs, message buses, and custom interaction metaphors.
• Recommendation: remove the extra orchestration and instruction layers; use the better models directly (e.g., Astra / Opus 5.5).

3) Treat code as the single source of truth; don’t generate docs/notes/specs

• Mistakes:
  • Agents taking notes after every change and committing them as markdown
  • “Context docs” or separate spec documents for every tiny change
  • “Spec-driven development” via documents rather than code
• Recommendation:
  • Let the agent write code
  • Commit the code; code itself is the “documentation”/spec because agents operate on tokens and can interpret it.
  • If comments are needed, use normal code comments.

4) Don’t treat chat history as “sacred context”

• Mistake: keeping one huge agent thread for months/features to preserve context.
• Recommendation:
  • Create a fresh conversation per feature/task
  • Mark it complete and close it so you don’t drag stale context around.
• Emphasis: the codebase is the real context, not the chat transcript.

5) Avoid long to-do lists / Kanban clutter for solo validation

• Mistake: solo builders filling months of tasks, often with markdown “task context” per card.
• Recommendation:
  • For new thoughts, add them to the agent immediately (via a “plus” / new prompt) instead of adding to a board.
  • If it’s not important now, don’t store it for later—clutter slows iteration.
• Core mindset: validate quickly with alpha users, not “productivity porn.”

6) Use fewer, simpler tools; avoid “messy” desktop app switching

• Mistake: juggling many UIs/tools (ChatGPT desktop, Claude desktop, CodeX desktop, etc.), running out of quotas, and doing handoff documents.
• Critique: consumer desktop apps can be overly verbose/distraction-heavy.
• Recommendation (tool-specific): use Enjoy as the central workflow to reduce tabs and context fragmentation.

7) Use “workshop” for controlled variations instead of iterative bickering

• Key workflow example: “workshop something” (e.g., change a website hero).
• Workshop behavior:
  • Generates multiple high-fidelity design/implementation directions
  • User chooses one option (e.g., “1 / 2 / 3 / 4”)
  • Then the agent executes—reducing back-and-forth.
• Claim: If you’re sending huge multi-message threads, you’re likely giving too much instruction/too many guardrails.

8) Don’t over-worry about early code quality during idea validation

• For startups/side projects not yet validated:
  • Prioritize shipping/validation over “clean architecture.”
• Code quality becomes more important when you’re in regulated/high-stakes domains (example: medical software).
• Argument: pre-MVP projects historically had messy code while moving fast; that’s normal.

9) Stop using branches / work trees early (start on main)

• Mistake: creating complicated branch/work-tree setups to prevent agents overwriting each other.
• Recommendation:
  • Start with one main branch
  • Run multiple agent tasks concurrently only if scope doesn’t meaningfully overlap
  • Use a lightweight commit pattern (“commit after every change” / quick per-agent commits)
  • Revert when issues occur.
• Claim: with Astra High, they’ve avoided overwrite incidents and didn’t need worktrees/feature branches in their projects.

---

“Enjoy” tool review / tutorial-like highlights (major product focus)

The speaker strongly endorses Enjoy as an “agentic development” environment.

Enjoy capabilities mentioned

• Side-by-side browser control via an agent (agent can edit UI and take screenshots).
• Conversation management: complete/close tasks so old context is hidden.
• Project/file browsing inside the app; can edit JSON.
• Switch between model/providers: mentions CodeX, Cloud Code, Opus 5.5, and tools continuing “where Codex left off” without handoff docs.
• Account switching for different cloud/code accounts.
• Docs/tasks: if you insist on to-dos, can create markdown/checklists and pin them—though the speaker prefers not to rely on this.
• Workflows integrated with CI/CD:
  • After pushing to main, run a workflow to monitor/fix failing CI tests.
  • Trigger a “desktop deploy” workflow to start/stop and manage local services (example: start yarn run dev-style server processes).
• Process visibility: Enjoy registers and manages running website processes so you don’t lose track.
• Multi-project workspace: switch between multiple projects (e.g., Enjoy, Ship Academy, experiments, notes).
• Mobile control: app accessible from phone to send commands/start tasks/create documents on desktop.

Tool positioning

• Built to reduce the “tab explosion” and context confusion from terminal + multiple desktop UIs.
• The speaker says they wouldn’t recommend it if it weren’t genuinely useful; Enjoy is described as born from observing people’s messy workflows.

---

Pricing / calls to action included

• Enjoy: 7-day free trial; link to enjoy.dev.
• Ship Academy (marketing/positioning course): shipacademy.com
  • Mentions that buying Ship Academy includes 1 year of Enjoy (value claimed).

---

Main speakers/sources

• Primary speaker: The narrator/host of the video (author of the advice), also the founder/creator behind Enjoy and Ship Academy.
• Referenced tools/models: Astra, Opus 5.5, Fable, plus “CodeX/Claude/Cloud Code/Cloud desktop” as comparison points.
• Referenced product: Enjoy (enjoy.dev) and Ship Academy (shipacademy.com).