1. Markdown as the New Code

The talk argues that some agent workflows can move from large imperative codebases into compact Markdown skills. The skill becomes a behavioral specification that the agent can execute directly.

2. Understanding Git Worktrees

Git worktrees allow multiple working directories to share one repository. They are useful for parallel agent tasks because each task can work in its own checkout.

3. The Complexity of the Initial Implementation

The original implementation required a large amount of code to manage state, branches, worktrees, task routing, and edge cases. Much of that complexity existed to coordinate agent behavior.

4. Deleting 15,000 Lines of Code

By moving the workflow into a skill, the team removed a large amount of orchestration code. The result was simpler to understand and easier to change.

5. Implementing With Skills and Subagents

The new design uses skills to describe the workflow and subagents to handle parallel tasks. Instead of hard-coding every branch, the agent reads the instructions and adapts.

6. The Structure of the New Skill

The skill defines when to create worktrees, how to assign tasks, how to avoid conflicts, and how to collect results. The Markdown file becomes the contract.

7. New Slash Commands and Workflow

Slash commands make the workflow accessible to users. They trigger the skill-driven process without requiring users to remember the implementation details.

8. Advantages of the New Implementation

The new approach is smaller, more flexible, and easier to iterate on. It also makes the behavior more inspectable because the rules are written in plain language.

9. Drawbacks and User Feedback

The tradeoff is that skill-driven behavior can feel less deterministic than code. Users may also need clearer feedback about what the agent is doing and why.

10. Ways to Improve the Skill

Potential improvements include better status reporting, clearer task boundaries, safer defaults, and stronger verification after subagents finish.

11. Cursor 3.0 and the Future

The talk points toward a future where agent workflows are partly product features and partly editable instructions. Skills may become a lightweight interface for shaping agent behavior.

Conclusion

The main lesson is not that code disappears, but that some orchestration logic can become clearer when expressed as instructions. The right abstraction is the one that makes the workflow easier to inspect and modify.