Stop Repeating Yourself: Google Engineer Turns Agent Constraints into a Reusable Skill Library
The same phrase "look at the existing implementation before changing" — you've probably told the Agent more than ten times. Start a new session, and it forgets again.
What's really troublesome isn't that it can't write code, it's that it derives from scratch every time the way you want it to work.
Run lint before committing, read the existing implementation before changing, only modify the files you point at — none of these requirements are hard. The hard part is that they only live in one conversation, and evaporate as soon as the session ends. Result: it changes fast, but when you unfold the diff you see it touched three extra classes, and you have to check line by line whether it broke something else on the way.
The first reaction is usually to switch to a stronger model, or to stretch the prompt a bit longer. But prompts are disposable — you explain it in this round, and you have to repeat it all in the next. On the 2026-11-12 GitHub Trending, there was a project pushing things in a different direction.
What holds back daily development is the constraints you have to re-state every time
addyosmani/agent-skills — a production-grade engineering skill library for AI coding assistants, from Google engineer addyosmani.
The one-line positioning given in the material: provide a set of production-grade engineering skills that AI Coding Agents can directly reuse, standardizing the "daily development practices that make Agents actually get work done."
The part worth pausing on isn't "skills" — it's "reusable" and "standardized." From the positioning, what it wants to replace is this step: previously, engineering constraints were written into each conversation's prompt and thrown away after use; now they're solidified into something the Agent can repeatedly read and check against item by item. Think of it as: the former relies on your good memory, the latter relies on a mechanism.
My view: writing engineering practices as reusable skills reduces Agent rework more than repeatedly tuning prompts. That claim can be debated, but at least it points the problem at a place where you can actually act.
For you, next time you experience rework, don't rush to switch models. Count how many times you've re-stated the same constraint. That number tells you more about where your own problem is than the star count.
Why the November 12 entry is worth clicking
The author's identity is right there. It comes from a Google engineer, and the material lists "source authority" as a reason for inclusion. The material gives only the identity, no specific job title, so I won't expand beyond that.
The buzz is for that day and verifiable. It entered GitHub Trending on 2026-11-12, gaining 812★ that day; the 96/100 in the material is the material's own heat score, not an official GitHub rating — don't mix the two.
The topic is close enough to daily work. The inclusion reason is blunt: the topic highly matches "AI coding assistants / daily development." It doesn't target benchmark sets; it targets the dialog box you open every day.
Put together, these three points say: this is material you can use "today" to decide whether to look at it. Heat only calls you to the door; whether it's worth entering still depends on whether the problem it solves is the one you're facing.
From the positioning, what does it turn "practice" into?
The material only gives positioning and summary, not the internal inventory of the repo, so this section only interprets — it doesn't pretend to have read the directory.
First, it turns practice into reusable units. From the "skill library" positioning, what it provides isn't a methodology article but a set of things the Agent can directly use. The difference: after reading an article you have to remember it yourself; after installing a skill you don't have to re-explain every time.
Second, "production-grade" means being accountable for results. It can be understood as: it cares whether what the Agent delivers can enter the normal development process, not how impressive it looks in a demo.
Third, standardization saves repeated communication. Once daily development practices are solidified, individuals and teams don't have to re-describe "how to do it" in every task.
The above three points are inferences from the positioning, not official project explanations. Which specific skills are included, how to install, which development stages are covered — the material doesn't provide these, and this article won't go into them; when needed, defer to the repo README.
For you, what you can judge now is "whether this direction is worth following," not yet "whether it's specifically good to use." Don't conflate the two.
Three things you can do today without installing it
- Write the rules into a file. Put an AGENTS.md in the repo, or add a section in CONTRIBUTING: read the existing implementation before changing, only modify the files you point at, which test to run before committing. Write it once, save dozens of repeated explanations later.
- Have the Agent report the change scope first. Before it acts, ask it to output "which files I plan to modify," then confirm before execution. This step blocks most cases of accidentally breaking things.
- When you say the same sentence a third time, archive it. Repeatedly appearing instructions are exactly the content that should go into a file. That's the lowest-cost standardization.
The following is a suggested validation path, not official project steps; none of the three require installing anything, and you can land step 1 before today's work ends. Step 2 takes effect faster: it changes the process, not the tool.
Who should look, and who should wait
It suits people who already use AI coding assistants in daily development and are bothered by "changes too much, afraid to merge"; also suits people who want to set a common practice for their team.
It doesn't suit people looking for a "stronger model, faster generation" tool — it works at the process layer and doesn't change model capability; doesn't suit readers who only occasionally ask the Agent to write a test; and doesn't suit teams that already have strict CI and review as a safety net — if the norm is already being enforced by people, adding another layer is just repetition.
If "AI writes fast but you're afraid to merge" is the real problem you're facing now, this November 12 Trending entry is worth five minutes of your time: at least it names the problem correctly.
What's the constraint you find yourself re-stating most often when using Agent to write code? Share it in the comments.
Info card
- Project: addyosmani/agent-skills
- Link: https://github.com/addyosmani/agent-skills
- Source: GitHub Trending (2026-11-12), +812★ that day; material heat score 96/100 (material's metric)
- Tags: #OpenSource #GitHub #AIProgramming #Agent
Top 1 from juejin.cn, machine-translated. The original thread is authoritative.
The rule 'say the same thing a third time, archive it' is the most practical. There's an extra layer of problem in a team: you archive it into your own config, your colleagues' agents still don't know, and when you hand off to someone else you have to repeat it all over again. Later we kept only one copy of rules and skills, put them in the shared environment everyone uses, with two or three people responsible for changes, and the rest just bring them along when assigning tasks.