Skills

Gavel routes skills from a frozen model’s internal states without loading skill text into context. It suggests large skill libraries may need model-native selection rather than metadata-heavy prompts.

A GitHub review agent is rebuilt with progressively less orchestration code, ending as instructions and setup files around general tools. Evals still remain the builder’s job.

Vercel’s data agent improved after replacing prescriptive specialist pipelines with a filesystem, Bash and company-specific context. Eve packages that pattern as conventions.

Impeccable turns design words such as “bolder” into concrete agent instructions. The useful pattern is to encode judgment in skills while keeping the builder responsible for direction and final polish.

Instruction capacity rose sharply, but long skill files still need evals. Current models can track thousands of constraints, with large differences by model, wording, and order.

LinkedIn scales a large internal agent catalog through search, schema lookup, and execution rather than exposing every tool at once. Its playbooks add task-specific operating knowledge.

SafeEvolve turns completed agent trajectories into reversible harness updates and policy training, linking runtime safeguards with learned multi-step behavior.

Vercel found that prose alone produced inconsistent agent-made pages, then paired design.md with fixed CSS primitives and repeatable evals to encode brand judgment.

Navan treats production agents as stateful services needing persistence, composable skills, traces, authorization gates, and trajectory-based tests before multi-agent complexity.

Shared agent skills can turn team know-how into portable workflows, but unmanaged catalogs create duplication and policy risk. Treat skills as versioned, evaluated dependencies.

A study of 8,351 Claude Code plugins finds instruction files and scripts often require coordinated maintenance, treating skills as evolving software rather than static prompts.

RedEvoAgent turns prior jailbreak trajectories into a compact attack skill, then keeps only validated improvements. It offers a more interpretable way to probe tool-using agents for unsafe actions.

Cloudflare’s GTM workflow shows a reusable agent pattern: preprocess business data, encode domain knowledge in skills, then separate drafting, verification, and tone.

Ramp’s GTM agents share a customer-data layer, durable execution, tools, and skills. The reusable pattern is to automate one narrow workflow, then extend the same substrate across teams.

Agent adoption becomes a team-systems problem: improve shared context and harnesses, assign platform ownership, and measure fewer human interventions instead of individual prompt speed.

Treat an agent’s first UI as a draft: encode recurring design dislikes, supply visual references, split work into focused prompts, and reserve time for iteration.

Reusable agent skills transferred better when induced from subtasks and stored as text. Whole-task skills often hurt versus no memory, so retrieval alone is not evidence that a memory helps.

Lease End replaced a fine-tuned intent classifier with skills and runtime context, cutting production fixes from about a week to under an hour. Higher API spend was offset by lower maintenance cost.

Hugging Face automated research-artifact outreach with a CLI, one skill, and a sandbox. The case shows when an agent can replace custom workflow code, but undisclosed automated outreach raises trust questions.

Compound engineering treats each agent mistake and product judgment as reusable context. The useful discipline is to invest in memory and review so the next feature becomes easier, not merely faster.

A manager can turn fragmented time into agent steering: prepare context, run bounded work overnight, then personally test and review small PRs before involving the team.

When production data cannot be retained, generate eval cases backward from sampled labels and reasoning paths, build records in layers, and let domain experts steer the pipeline.

Reelful maps the coding-agent pattern onto real-footage editing: analyze media, approve a plan, edit as Remotion code in a sandbox, then verify before rendering.

Production browser agents need more than a capable model: a domain harness, compact site knowledge, consistent rendering, secure authentication, and human approval for sensitive actions.

A useful agent knowledge base starts with abundant raw Markdown, then adds controlled tags, backlinks, and generated indexes. Scheduled agents can maintain it, but sync and taxonomy need explicit rules.

Coding-agent adoption is a team systems problem, not an individual tooling choice. Share effective practices, disclose context progressively, and build automated loops that detect and repair weak output.

The talk argues that agents are an early interface, not the endpoint, and demonstrates reusable primitives for AI-native software: persistent subagents, compressed context, loaded skills, generated UI, and voice.

SkillProx evolves reusable agent instructions through measured retries, regression rollback, and utility-based pruning, reporting a 3-point accuracy gain over its strongest baseline.

A structured multi-agent reviewer closed part of the gap on rule-heavy documents, suggesting explicit taxonomies, specialized skills, and verification beat a single generic review pass.

Agent Plugins 1.0.0 packages Skills and MCP servers in a shared format supported by five major agent-client families, reducing client-specific repackaging.

Agent Plugins 1.0.0 standardizes how Skills and MCP servers are packaged, letting extension authors target several agent clients with one portable directory.

OpenAI is adding education plugins to ChatGPT Work and Codex for teaching, learning, research, and building. The announcement provides no details on capabilities or access.

Cursor’s cloud-agent adoption grew after it treated the dev environment as agent infrastructure: Linux parity, one discoverable CLI, end-to-end testing, and automated repair.

Production agent velocity depends less on model swaps than on automating the developer loop: isolate parallel work, encode workflows as skills, connect tools, and keep humans as verifiers.

Treat agent skills as supply-chain dependencies. Nubank scans them locally and in CI with deterministic rules plus LLM review, then gates marketplace distribution and feeds findings into vulnerability management.

FactSet treats skills as versioned product features and the harness as their runtime. Routing descriptions, model-specific evals, access controls, and governance matter as libraries grow.

Skill-SP turns agent skills into units for verifiable self-play: generate tasks, solve them, then update the skill library from execution feedback. The abstract provides no per-benchmark effect sizes.

Procedural skills can make an agent fail tasks it previously solved. Evaluate gains and regressions separately, and design skills to preserve input grounding and output verification.

Persistent Codex workflows become more useful with reusable skills, memory, app-aware context, and scheduled thread check-ins—but computer use needs explicit boundaries and stopping rules.

Atlan’s agent experiments argue for shared, versioned context instead of per-agent memory: a portable layer for business facts, skills, norms, retrieval, and feedback across changing harnesses.