-
“once the plan is good, the code is good. with opus 4.5, once the plan is solid, the model can execute it pretty much perfectly.”
-
“you should never have to comment about something twice. every code review issue becomes a durable rule in claude.md so the team never repeats feedback.”
-
“if you have to write code but you can never run it or see the output, it’s just not going to be good. give claude a way to verify its output—like running tests or using a browser—and the results will be way better.”
boris demonstrates how claude cowork makes ai agents accessible to non-technical users by enabling file management, browser control, and task automation through a simple ui, while emphasizing that productivity comes from running multiple tasks in parallel rather than speed alone. he shares his viral claude code workflow: start in plan mode, switch to auto-accept once the plan is solid, maintain a shared claude.md as compounding team knowledge, and always give claude a way to verify its own output through tests or browser feedback. the key insight is that smarter models like opus 4.5 with thinking are actually faster and cheaper overall because they require less steering and use fewer tokens despite higher per-token costs.
What are the crucial points in this article or video that make it iconic, ideas I want to remember for the rest of my life?
-
compounding knowledge beats one-off fixes: never give the same feedback twice—capture every mistake, bug, or pattern in a shared knowledge base (claude.md) so it becomes durable institutional memory that improves every future interaction.
-
verification drives quality: whether you’re painting, coding, or delegating to ai, the ability to see and test output is what separates mediocre from excellent results—always give agents a feedback loop.
-
parallelism over speed: the future of productivity isn’t doing one thing faster; it’s tending multiple intelligent agents working simultaneously while you steer outcomes and unblock progress.
boris wants people to understand that ai agents like claude cowork and claude code are most powerful when you shift from “chat for answers” to “delegate real work”—running multiple tasks in parallel, building compounding team knowledge, and giving the model ways to verify its own output.
- plan-first execution: start sessions in plan mode, iterate until the plan is solid, then switch to auto-accept for implementation
- compounding engineering / claude.md: a shared, version-controlled knowledge base that captures every mistake and review comment so feedback never repeats
- verification loops: giving claude tools (browser, tests, simulators) to check its own work dramatically improves output quality
- agentic ai: models that take action across tools, files, and browsers—not just text-based chat
- parallel tasking: running 5-10 claude sessions simultaneously and “tending” to them rather than deep-focusing on one
- skills & mcp: repeatable procedures and tool integrations that help agents perform better in specialized software
- run multiple claude sessions in parallel (5-10 tabs) and bounce between them
- start every session in plan mode; iterate on the plan before execution
- switch to auto-accept edits once the plan looks good
- maintain a claude.md file checked into git; update it every time claude makes a mistake
- use the claude github action to tag @claude in prs and issues for automated fixes and knowledge base updates
- give claude browser access (chrome extension) so it can verify its own output
- use opus 4.5 with thinking for everything—it’s faster and cheaper overall despite higher per-token cost
- install claude code on mobile (ios/android) and kick off tasks throughout the day
- for cowork: start simple, mount a folder, try basic file tasks before adding skills or customization
- create skills only when you hit specific software workflows cowork isn’t great at yet
- how will the “compounding knowledge” pattern (claude.md) evolve as teams scale—will we need new tooling for knowledge base management and conflict resolution?
- what happens when multiple agents with different knowledge bases need to collaborate? how do we handle knowledge synchronization?
- as agents become more autonomous, how do we design effective “tending” workflows—what does good agent supervision look like at scale?
- will the shift from “speed” to “parallelism” change how we structure work and teams fundamentally? what new organizational patterns emerge?
- how do we measure and optimize for “agent productivity” vs. traditional human productivity metrics?
- what are the limits of verification loops—when does self-verification break down and require human judgment?
- how will skills and mcp integrations become standardized—will there be a marketplace or ecosystem?
- what’s the right balance between agent autonomy and human steering as models get smarter?
people:
- dan shipper (compounding engineering concept)
- jean-claude van damme (pronunciation reference)
- dario amodei (anthropic ceo, mentioned prediction about coding)
resources & tools:
- claude code (terminal-based coding agent)
- claude cowork (ui-first agent for non-technical users)
- claude.md (team knowledge base pattern)
- claude github action (for pr automation)
- mcp (model context protocol)
- chrome extension for claude
- claude ios/android apps
- opus 4.5 with thinking mode
concepts worth exploring:
- mechanistic interpretability (studying ai neurons)
- alignment research at anthropic
- prompt injection protection
- agentic ai vs. chat-based ai
- computer use capabilities
- tool use in ai models