Robert Dimitrov

4 Takeaways From Anthropic on Context Engineering for Next-Gen LLMs

When testing Claude Opus 5 and Claude Fable 5, Anthropic removed over 80% of Claude Code's system prompt with no measurable loss in coding evaluations.

As AI models evolve, over-constraining them with rigid guardrails creates conflicting instructions and wastes context space. Here are 4 direct shifts in how to approach context engineering:

1. Shift from Hard Rules to Model Judgment Older models required strict rules (e.g., "never write multi-paragraph comments") to prevent bad outputs. Advanced models have better judgment. Replace micromanagement with contextual guidance, like "write code that matches the comment density and style of the surrounding file".

2. Interface Design Over Few-Shot Examples Providing exhaustive examples for tool usage can inadvertently constrain the model's exploration space. Focus instead on well-designed tool interfaces with clear parameter definitions and enumerations that signal intended behavior naturally.

3. Use Progressive Disclosure Over Upfront Context Avoid cramming every spec, workflow, and verification check into a central system prompt or CLAUDE.md file. Use dynamic loading, modular skills, or deferred tool definitions so context is only loaded when a specific task requires it.

4. Eliminate Instruction Duplication Repeated instructions across system prompts and tool descriptions are no longer necessary. Consolidate tool-specific guidance directly within the tool's description rather than repeating it globally.

Cogito: Chasing a Dribbble-Worthy Microblogging App

Cogito is where I went looking for social media as eye candy — a microblogging app that could hold its own on Dribbble, not just function. It started years ago as React, a Node API gateway, and Go and Python microservices behind it, then sat unfinished for a long time. I finally came back to it.

The frontend is Svelte now. The backend is properly architected as microservices across Go and Rust, sitting behind an API gateway and talking gRPC internally, deliberately overengineered past what a hobby feed actually needs — building something complete and pretty was the whole goal.

The real focus this time was the design brief: spending real time in the UI/UX weeds — light and dark themes, reposts, hashtags, @mentions, hover and focus states, cover photos and avatars — until the feed felt like something worth screenshotting. That, plus the architecture itself, was where AI-assisted engineering did the most work: rounds with Claude and GPT on hierarchy, contrast, and service boundaries, instead of solo trial and error.

It's completely finished now — feed, profiles, reposts, notifications, search, the works — feature-complete, polished, and backed by infra and services built to actually scale.

3 Takeaways From Travis Kalanick on Scaling Companies and Bending Reality

Building category-defining companies requires a fundamentally different mindset. Here are 3 key takeaways on innovation, strategy, and execution:

1. Focus on Why You Start, Not Where You Start Great platforms rarely stay where they begin. Amazon started with books before building AWS. Uber started with black cars before scaling to Eats, freight, and autonomy. Start with a problem you are passionate about, and let your management capacity and vision unlock adjacent industries over time.

2. Bend the Future Towards the Present If an outcome is inevitable in 20 years (like autonomous delivery or automated food production), the real entrepreneurial opportunity lies in shrinking that timeline to 5–7 years. Breakthroughs happen when you actively bend reality toward the present.

3. Manage the "Meta-Problem" (Creation vs. Solution) To grow, leaders must constantly create new problems (e.g., expanding to new regions or launching new verticals). However, the rate at which you create problems must never outpace your capacity to solve them. When you get underwater, stop problem creation until your team — and personal bandwidth — catches back up.

Phasma: My Old Learning Project, Rebuilt Into a Full-Blown Production App

Phasma started years ago as the project I used to actually learn Angular, Node, Docker, and Kubernetes — the kind of throwaway app you build specifically to break things and figure out how they work. I just finished completely rewriting it, and it's not a throwaway anymore.

The stack is now Svelte on the frontend and Go on the backend, fully expanded with hashtags, @username support in posts, real search, and a complete modern glassmorphism redesign.

That first build taught me a stack. This one taught me something I'd never really practiced: AI-assisted engineering — working through UI/UX itself, hierarchy, contrast, spacing, motion, in rounds with Claude and GPT instead of framework docs. Different kind of learning project, same instinct to ship it once it actually worked.

It's gone from "thing I learn with" to a full-blown product — feed, profiles, likes, comments, notifications, the works — ready to delight with its visuals and scale with the infra powering it.

5 Takeaways From Chris Yeh on How to Blitzscale in Winner-Take-Most Markets

Building a multi-billion dollar platform requires a completely different growth strategy than what is taught in traditional business school. Here are 5 core takeaways on how to apply Blitzscaling:

1. Prioritize Speed Over Efficiency Blitzscaling is the strategy of prioritizing speed over efficiency in the face of uncertainty. It is not appropriate for every business, but it is essential when entering a winner-take-most market with a strong distribution advantage. If you don't scale fast, a competitor will, and you'll never catch up.

2. Launch a Product You're Ashamed Of As Reid Hoffman famously noted, if you aren't embarrassed by your first release, you launched too late. Don't spend months perfecting features based on internal intuition. Launch early, collect real-world user feedback, and iterate rapidly to fix actual customer pain points.

3. Master the 5 Organizational Stages As your company grows by orders of magnitude, your structure must fundamentally evolve:

   • Family (<10 people)
   • Tribe (10–99 people)
   • Village (100–999 people)
   • City (1,000–9,999 people)
   • Nation (10,000+ people)

   What got you to one stage will not get you to the next. You must transition from individual execution to management, and shift internal communication from personal dialogue to broadcasting.

4. Do Things That Don't Scale (At First) Avoid building massive, rigid infrastructure for millions of users on day one. Market realities and customer needs change too rapidly. Build for the present moment, adapt constantly, and accept that change is the only constant.

5. AI Creates the Ultimate Blitzscaling Loop AI models naturally possess winner-take-most dynamics: better models attract more users, more users generate more data, and more data creates even better models. Using AI allows teams to achieve massive scale with fewer resources and smaller teams than ever before.

4 Takeaways From Andrej Karpathy on Software 3.0 and Agentic Engineering

Andrej Karpathy recently said he's never felt more behind as a programmer — a strange thing to hear from someone who helped build modern AI. His point: sometime around December, agentic coding tools crossed a line from "occasionally helpful autocomplete" to "I can't remember the last time I corrected it." Four ideas from the conversation worth sitting with:

1. Software 3.0: Prompting Is the New Programming Software 1.0 was explicit code, 2.0 was learned weights from training data, and 3.0 is prompting an LLM directly — the context window becomes your lever over what's effectively a general-purpose, programmable computer. The clearest example: installing a tool used to mean running a shell script; now it can just be a paragraph of instructions handed to an agent, which reads your environment and figures out the rest.

2. Jagged Intelligence Comes From What's Verifiable Models are superhuman at math and code because labs can throw massive reinforcement learning at anything with a verifiable reward signal — and stay strangely weak outside that footprint. The same model that can refactor a 100,000-line codebase or find zero-day vulnerabilities will confidently tell you to walk 50 meters to a car wash instead of driving. The gap isn't random noise; it's roughly the boundary of what actually got reinforcement-learned.

3. Vibe Coding Raises the Floor; Agentic Engineering Protects the Ceiling Vibe coding means anyone can get software working. Agentic engineering is the harder discipline underneath it — coordinating powerful, inconsistent agents to move fast without dropping the quality bar professional software always required. Karpathy's read: people who are genuinely good at this aren't 10x faster, they're well past it.

4. You Can Outsource Thinking, Not Understanding Agents can execute almost anything now, but someone still has to know what's worth building and why — write the spec, catch the agent's weirder mistakes (like matching payment accounts by email instead of a real user ID), and hold the taste and judgment the model doesn't have. That's the actual bottleneck now, and it doesn't disappear just because the code got faster to produce.