I barely review the code anymore after I added these skills

Key technological concepts / product behavior

• “Skills” as agent-callable functions: The speaker argues that AI coding agents (e.g., Codex/Claude Code) should be guided with skills rather than manual, repeatedly typed instructions in prompts. Skills act like reusable functions the agent can call at the right time.
• Minimal or empty AGENTS.md: Contrary to common practice, the speaker’s AGENTS.md is essentially empty. The behavior changes come primarily from adding skills in a skills/ folder, not from prompting every time.
• Just-in-time “prompting program” behavior: Newer models (mentioned: Claude and Codex, including “Codex with GPT‑5.6”) are described as being trained to discover which skills apply based on task context and the skill’s description—reducing the need to hardcode tool/function call sequences in every prompt.
• Skill descriptions matter: The speaker emphasizes that the skill’s description is used by the agent to decide whether it’s relevant (e.g., “taste-driven design” decisions for UI copy/layout).

Demonstrated workflow / review + testing outcomes

• Example: Implementing a new menu item in a React app via a single-sentence prompt.
• Observed automated skill actions during the run:
  1. Pulls React/Vercel best practices skills automatically (via context/project type).
  2. Detects a UI change (copy + menu placement) and uses a “taste review” skill—framed as prompting Claude to investigate design decisions.
  3. Runs a “review readiness pass” to add useful code comments (Codex allegedly usually omits them otherwise).
  4. Simplifies code (shorter names, less verbosity, combines/normalizes related logic).
  5. Uses a desktop app testing skill to click around the built app end-to-end to validate behavior.
• Claimed benefit: not only correct code, but code that matches the speaker’s preferred React guidelines/style, includes review-oriented comments, and is verified by actual app interaction.

Guides / tutorials implied in the talk

Installing skills via a CLI

• Mentions a “skills marketplace” concept powered by GitHub repos.
• Workflow: run npx skills add with a repo/org to pull skills into a local skills folder.
• Skills are Markdown and can be modified after install.

Writing a skill (authoring guidance)

• Skills should be concise; the speaker prefers handwritten skills to avoid unnecessary context “fluff.”
• Skill descriptions should specify what the skill does and when to use it.
• Provide explicit instructions on what to do (e.g., call out to Claude for taste-driven decisions).

Structuring “wrappers” / composed skills

• The speaker uses a wrapper approach like “review readiness” that combines multiple skills (e.g., simplify + code comments) so the agent can call a single higher-level skill when code is ready for handoff.

Specific skills described (features + purpose)

1. React best practices (from Vercel)

   • Adds guidance like using useLayoutEffect appropriately and avoiding misuse of useEffect.

2. Taste review (Claude-assisted design decisions)

   • Triggered for UI polish tasks: copywriting, prose/phrasing, naming, formatting, UI placement.
   • The description defines relevance; the body instructs calling Claude when the agent reaches a taste/design decision.

3. Code comments

   • Encourages plain-English “why” comments, not “what the code does” or mechanical restatements.
   • Goal: compensate for Codex’s tendency to omit comments unless they exist nearby.

4. Simplify / code refactoring readiness

   • Triggered when code is “ready for human review.”
   • Targets: shorter identifiers, combine related concepts, inline library helpers when possible, use derived values, reduce verbosity.
   • Can review all branch code or only uncommitted changes, depending on preference.

5. Review readiness wrapper

   • Combines simplify + code comments (+ optional extras) as one function-style skill.

6. End-to-end desktop app testing skill (Electron-focused)

   • Designed so the agent can run the built app, open it, click around, and verify behavior.
   • The skill writes/uses Node.js scripts within an Electron harness to screenshot/verify and inspect runtime behavior.
   • Mentions workarounds like environment variables (e.g., bypassing some restrictions; using DevTools).
   • Emphasizes: having this skill prevents the need to manually copy/paste client console errors back into prompts.

Review / quality assurance analysis claims

The speaker frames skills as improving:

• Code correctness: end-to-end run verification via desktop automation.
• Code quality: simplification + better comments.
• UI/UX quality: Claude-aided “taste” review for copy/layout decisions.
• Style compliance: React best practices.

Also mentions an audit approach:

• Ask the agent to trace prior conversations to find repeated prompt patterns and convert them into skills.
• Another idea: have it review system architecture docs (e.g., CONTEXT.md) before feature work, because sometimes it misses architecture context.

Main speakers / sources

• Main speaker: the video author (unnamed in subtitles), speaking about Codex/Claude Code skills workflows.
• Referenced external sources:
  • Vercel (React best practices skill; skills installation via a skills marketplace/CLI).
  • Matt Pocock (mentioned as an external skill author; installed one unrelated to the described workflow).
  • Claude Code / Claude (used conceptually for taste/design decision assistance).
  • Codex (the coding agent being guided with skills; also mentioned with “GPT‑5.6”).