vanducng

[Elon Musk @elonmusk]

This has my full support.

Jensen is right.

[Thariq @trq212]

We removed ~80% of the Claude Code system prompt for our newest models, this is what we've learned about writing system prompts, skills and Claude.MDs for them. https://t.co/6DZwSrZjE9

[vanducng @vanducng]

Unbelievable.

[Guillermo Rauch @rauchg]

I’m excited to welcome two legends of developer tools, Pete Hunt (@floydophone) and Nick Schrock (@schrockn), to Vercel.

Pete was one of the pioneers of @reactjs at Meta. He made an early bet to power Instagram Web with ⚛️ React, evangelizing it internally and externally. He will be running Frameworks and leading @nextjs. I couldn’t imagine a better person to lead React’s most popular framework to even greater heights.

Nick co-invented @graphql, solving some of the gnarliest data infrastructure and access issues at Facebook scale, with a delightful developer experience. He will be working on Agentic Developer Experience, solving the problem of enabling the next billion agents and leading the way to a future of self-improving software.

It’s a dream-come-true for a founder of a startup to welcome engineering minds of this caliber who are also wonderful humans. You probably want to work with them, and they’re hiring 😁. Their DMs are open, from job applications to bug reports!

[vanducng @vanducng]

If most domain knowledge can now be encoded into CLAUDE.md's, skills, and docs for agents, what happens to the tacit learning humans used to get by struggling through the ramp-up period themselves? Does skipping that struggle change how deeply new contributors actually understand the systems they're shipping code into?

[vanducng @vanducng]

Been really impressed with GPT-5.6 lately, working through a legacy PHP project and it's been a great partner for modernizing the codebase while keeping everything stable. What stood out most was the transparency about issues and how quickly they were tackled after launch. #GPT5.6

[Rob Hallam @robj3d3]

PRO TIP: Copy this article into Fable 5 and tell it...

"Read this article, review my current workflow, and tell me 5 things I can do to be more productive"

[Harrison Chase @hwchase17]

wikis for memory are all the rage - we wrote about this yesterday

today we're releasing an open source example for doing this code bases

[Andrew Ng @AndrewYNg]

“Loop engineering” is a hot buzzphrase after mentions of it by Boris Cherny (Claude Code’s creator) and Peter Steinberger (OpenClaw's creator) went viral on social media. Loops are now a key part of how we get AI agents to iterate at length to build software. In this letter, I’d like to share my 3 key loops, shown in the image below, for building 0-to-1 products. These loops guide not just how I build software, but also how I decide what software to build.

Agentic coding loop: Given a product specification and optionally a set of evals (that is, a dataset against which to measure performance), we can have an AI agent write code, test its work, and keep iterating until the code is bug-free and meets its specification. This idea of closing the loop took off around the end of last year, and it has been a game changer in enabling coding agents to work longer productively without human intervention. For example, over the weekend, I was building an app for my daughter to practice typing, and my coding agent could easily work for around an hour, using a web browser to check what it had built multiple times before getting back to me, without needing my intervention.

The engineering loop executes quickly. Every few minutes, the coding agent might build and test a new version of the software. I hear frequently from developers who are finding new ways to engineer more effective engineering loops. This is an active area of invention!

Developer feedback loop: In this loop, a developer examines the current product and steers the coding agent to improve it. Last year, a lot of developers (including me) were acting as the QA (quality assurance) function for our coding agents, manually finding bugs and then asking the agent to fix them. But with coding agents much more able to test their own code, the amount of time we need to spend on this function has decreased significantly. This allows us to make higher-level product decisions, such as what key features to offer, where the UI needs improvement, and so on.

The developer-feedback loop operates over time intervals between tens of minutes and hours — that's how frequently a developer might review a product and give feedback. In the case of the typing app, I changed my mind a few times about the visual design, what cat costumes she can unlock as she learns (she loves cats), and the user flow for a grown-up to log in and steer the child's learning experience.

When a developer has a clear vision for what to build, it is still a lot of work to translate that vision into a specification for a coding agent to implement. Further, after the developer has seen an implementation, they might update (or perhaps clarify) the spec to steer it toward what they want. If you find that the system repeatedly runs into certain problems, building a set of evals for the agent becomes useful.

AI-native teams are increasingly using AI to help shape product direction, for example, automating the gathering and analysis of usage data, summarizing written and verbal customer feedback, or carrying out competitive analysis. However, for pretty much all the products I’m involved in, I see humans as having a significant context advantage over current AI systems — we know a lot more than the AI system about the users and the context the product has to operate in — and thus humans play a critical role. Many people describe this human contribution as “taste,” but I prefer to think of it as humans having a context advantage, since that gives us a clearer path to helping AI systems get better. This also speaks to why this step can’t be automated: So long as the human knows something the AI does not, human-in-the-loop is needed to to inject that knowledge into the system.

External feedback loop: This includes a wide range of tactics like asking a few friends for feedback, launching to alpha testers, or putting the code into production with A/B testing. These tactics are usually slow, rarely taking less than hours and sometimes taking days or even weeks. This data informs the developer vision, which in turn continues to drive the detailed product spec, which in turn drives the coding agent.

With coding agents speeding up software development, more engineers are starting to play a partial product management role. For many engineers who are growing into this role, the hardest part is shaping the product vision and striking a balance between building (bridging the gap between vision and spec) and getting user feedback to evolve the vision. It is important to do both!

I will write more about how to do this in future posts, but for now, I find it encouraging that engineers are playing an expanded role (just as product managers and designers now do more engineering).

[Original text: The Batch]

[Ashpreet Bedi @ashpreetbedi]

5 skills in my self-driving agent-platform:

- create-new-agent
- improve-agent
- extend-agent
- eval-and-improve
- review-and-improve

The future is here, just not evenly distributed.

[Khairallah AL-Awady @eng_khairallah1]

Anthropic pays $750,000+ a year for engineers who know how to build LLMs from scratch.

Stanford just released the exact lecture that teaches it - 1 hour 44 minutes, free, straight from CS229.

Bookmark and watch it this weekend.

It'll teach you more about how ChatGPT & Claude actually work than most people at top AI companies learn in their entire careers.

[Anatoli Kopadze @AnatoliKopadze]

https://t.co/eq0oL4fIaR

[vanducng @vanducng]

https://t.co/TLOAvJfddD

[Codez @0xCodez]

A senior Anthropic engineer just dropped 11-page PDF on "Loop Engineering" for agentic systems.

The shift: you stop prompting the agent. You build the system that prompts it instead.

Schedule → Discover → Build → Verify → Repeat

Every loop runs one turn, five moves:

• Discovery: it finds its own work - failing CI, open issues, recent commits - instead of being handed a list.

• Handoff: each task gets an isolated git worktree so parallel agents don't collide.

• Verification: a second agent, told to assume the code is broken, reviews the first. The "thing that can say no."

• Persistence: results get written to disk, never left in a context window that gets flushed.

• Scheduling: an automation wakes it on a timer. That's what makes it a loop.

The key insight: an agent grading its own work always praises it.

This 11-page PDF changed how I'm building agentic systems today.

Read it now, then explore the article below.

[Anatoli Kopadze @AnatoliKopadze]

Anthropic engineers just showed how they build a full app from scratch, using a loop of agents

40 minutes from the team behind Claude Code

they used three agents: one to plan, one to build, one to judge, cycling until the app actually works

the winners won't have the smartest model, they'll have the best loop

watch it, then read the full guide on how to actually use loops below

[Deedy @deedydas]

Most software engineers are facing an identity crisis bordering on depression.

As CTOs aggressively evangelize tokenmaxxing, a class divide ensues.

The lazy. The lazy push code. They don't write it. They don't manually test it. They don't even read it. They're on autopilot. See Jira ticket, prompt for task, submit code. Many of them are barely on their computer the whole day. A comment on the PR asking why they did this? The lazy ask AI. A Slack message? The lazy ask AI. Need to prepare for standup? The lazy ask AI. As long as it sounds enough like them and isn't detected. Some of the lazy are even overemployed, and work multiple jobs. The lazy smart ones get away with this, and even rewarded. After all, software engineering for the lazy is just a dance to convince your colleagues you're smart and hard working.

The craftsmen. The craftsmen are tired. Very tired. 15 PRs in queue. Slack blowing up. The entire burden of review falls on the craftsman. The burden of understanding. They try. They work their way through the code, thoughtfully commenting to improve what ships. The response? A lazy: "That's a clever idea! You're absolutely right." with an incorrect change. It's fine, the craftsman says. I can fix them. They write a doc urging his colleagues to be better. The next day? 20,000 line PR to review. Day after day, their workload grows. Bugs seep into production. No one seems to care. Another round of AI is thrown at it. Their animosity to their colleagues rises. Eventually, they give up. It's just not what it used to be. The craft they loved is dead. They eventually wake up, a lazy.

This isn't all companies. Many companies are genuinely more productive, adopt the right set of principles and practices around AI development and have highly talented teams that trust each other. It tends to happen in bigger companies that are 10+yrs old with a higher talent variance. But it happens. A lot.

[Cursor @cursor_ai]

We're launching code storage and git hosting.

Origin gives teams and agents a place to host, review, and collaborate on code.

Available this fall. Join the waitlist.

https://t.co/uamaIarJXY

[vanducng @vanducng]

Rolled OpenCodeReview into my default PR workflow today.

Instead of copying a full GitHub Actions job into every repo, I published one reusable workflow at https://t.co/dEf2Pytf28: .github/workflows/code-review.yml.

Each project keeps a thin caller: PR open/reopen, issue comments, pull-requests: write, and explicit OCR_LLM_* secrets. The reusable workflow owns the sharp edges: install @alibaba-group/open-code-review, run ocr review --from origin/<base> --to <head> --format json, post inline PR comments, skip bot PRs by default, and still allow /ocr or @ocr on demand.

Rolled it to 12 repos across dataplanelabs/* and vanducng/*. Each caller can keep its own .opencodereview/rule.json, so infra, Go, Python, Astro, and config repos do not need the same review taste.

The useful lesson: centralize policy, keep callers boring, pass secrets explicitly. secrets: inherit is too easy to get wrong when a public reusable workflow is called by private repos or across owners.