skills

Generate a terminal-theme cover image for a blog post — renders an on-brand HTML template to PNG with headless Chrome. Use when the user wants a cover image, thumbnail, or og-image for a post, or when a finished post is missing its cover. Scope is the site's terminal-style covers (dark green, $-prompt, terminal window); photo/YouTube-style thumbnails with Dan's face are the video `thumbnail` skill, NOT this one.

Research, refine, and scope a single video idea Dan already has — validate demand with evidence, find the angle competitors are missing, and define what the video covers, ending in a go / reframe / park verdict. Use whenever Dan brings his own idea rather than asking for new ones — "I want to make a video about X", "is X worth a video?", "help me scope this video", "research this topic for a video", "what should I cover in a video on X", "how should I angle this". Finding ideas from scratch is `video-ideation`; turning a settled, scoped idea into a title/thumbnail/intro is `video-packaging`. This skill is the bridge between them.

Add branded motion graphics and camera moves to a YouTube video — lower thirds, section titles, callouts, punch-in zooms — transcript-driven placement, rendered from the terminal-style template library and composited with ffmpeg. Chains after rough-cut. Use when Dan says "add graphics", "add a lower third", "motion graphics pass", "add zooms", "punch in on that", "put my name on the intro", or wants callouts / titles / animations / transitions on a video. Do NOT use for cutting (rough-cut), thumbnails/titles (video-packaging), or captions.

Produce a rough cut of a raw YouTube recording — trim dead air, remove filler words, and resolve retakes while preserving natural pacing. Handles both talking-head and screen-share footage; the output is a first pass to finish in an editor, not a final render. Use when Dan drops a video file and says "rough cut this", "first pass on this", "trim the silences", "cut the dead air", "remove the ums", "remove the duplicates", "I re-recorded some parts", or "clean up this recording". Do NOT use for titles/thumbnails (video-packaging), extracting short clips, captions, zooms, or b-roll.

Chop a long-form video into 30–60 second 9:16 vertical shorts — find the standalone moments in the transcript, reframe per segment (face crop for talking-head, stacked layout for screen-share), and burn in word-by-word "karaoke pop" captions. Chains after rough-cut. Use when Dan says "make some shorts", "chop this up", "pull some clips out of this", "clip this video", "vertical clips", "9:16", or mentions Shorts / Reels / TikTok for an existing video. Do NOT use for the long-form first pass (rough-cut), graphics on the long-form video (motion-graphics), or titles/thumbnails (video-packaging).

Research-driven YouTube video ideation for Dan Vega's channel (Java, Spring, AI, and developer tools). Use this whenever Dan asks for video ideas, wonders what video to make next, wants to know what's trending in the Java/Spring/AI space, asks what topics are doing well on YouTube, or mentions ideation, content planning, or "what should I cover". Even a vague "I'm stuck on what to make" should trigger this skill. Produces a ranked idea brief where every idea is backed by evidence of real demand.

Scaffold a new YouTube video project on disk from Dan's 2026 template — copy /Users/vega/youtube/2026Template into a new PascalCase project folder and rename the Premiere project file to match. Use when Dan says "new video project", "scaffold a project", "set up a project for <video name>", "create the folders for <video>", or gives a video title and asks to start the project. Do NOT use for deciding what to film (video-ideation), titles/thumbnails (video-packaging), or editing footage (rough-cut).

Render the final thumbnail art for a YouTube video — composes real photo cutouts of Dan with HTML/CSS templates in the channel's design language (dark green, big white type, one green accent) and renders to PNG with headless Chrome; no AI image generation. Use when Dan wants the actual thumbnail image made — "make the thumbnail", "render the thumbnail", "thumbnail for <video>", or when a video-packaging concept is ready to become art. Do NOT use for thumbnail *concepts*/creative direction (video-packaging), blog cover images (blog post-cover), or video ideas (video-ideation).

Republish a Beehiiv newsletter edition on danvega.dev — fetch the post via the Beehiiv MCP server, convert it to the site's markdown (frontmatter, :YouTube/:TweetEmbed components, local images, house footer), run a light quality pass, and save it into content/newsletter/. Use when Dan says "publish my newsletter", "convert the latest newsletter", "move this week's newsletter to the site", or names a specific edition to bring over. Do NOT use for writing a new post (new-blog-post), optimizing existing content (seo-optimize), or sending the newsletter itself (that happens in Beehiiv).

Turn one chosen video idea into a congruent package — final title, thumbnail concept, and first-30-seconds intro — for Dan Vega's YouTube channel. Use when Dan has decided what to film and wants it packaged, or mentions titles, thumbnails, hooks, intros, or "packaging" for a specific video. Input can be an idea from a video-ideation brief, a plain topic, or source material Dan hands over — code, a repo, a blog post, an article, release notes, or documentation the video will be based on. Figuring out WHAT to make is `video-ideation`; this skill packages an idea that is already chosen.

Write, rewrite, or review a README so it serves its actual reader — structure and emphasis chosen by project type (CLI, library, web app/service, monorepo, template/scaffold, internal tool). Use whenever the task is creating or improving a README or top-level project docs: "write a README", "document this project", "clean up the README", scaffolding a new repo, or prepping a project to go public. Do NOT use for API reference docs, CONTRIBUTING guides, changelogs, or writing ABOUT a project (blog posts, announcements).

Version REST endpoints with Spring Framework 7's first-class API versioning — the `version` attribute on @GetMapping/@RequestMapping plus ApiVersionConfigurer, instead of manual path routing or separate controllers. Use when a task in a Boot 4 / FW 7 project is about evolving an API you EXPOSE while keeping old clients working — "v1 vs v2 endpoint", "version this response", header/media-type/path versioning, deprecation/Sunset headers — even if the user never mentions a version (check the build file). Do NOT use for choosing a client to CALL a versioned API (see http-interface-clients), or for general request mapping unrelated to versions.

Register beans programmatically in Spring Framework 7 with the BeanRegistrar interface — pick or configure beans at startup from properties/environment/conditions, with a clean lambda API and AOT support. Use when a task in a Boot 4 / FW 7 project needs DYNAMIC bean definitions — "register a bean based on a property", conditional wiring the @Conditional annotations can't express, plugin/strategy selection, or the user reaches for BeanDefinitionRegistryPostProcessor / BeanFactoryPostProcessor / ImportBeanDefinitionRegistrar — even if the user never mentions a version (check the build file). Do NOT use for ordinary static beans (just use @Bean/@Component) or for simple on/off toggles that @ConditionalOnProperty already handles.

Build declarative HTTP clients in Spring Boot 4 with @ImportHttpServices + @HttpExchange interfaces — zero boilerplate, no manual RestClient/proxy-factory wiring. Use whenever a Boot 4 app needs to CALL another HTTP/REST service (third-party API, another microservice): the user says "client for service X", "consume this API", "fetch from an endpoint", or reaches for RestTemplate / WebClient / RestClientAdapter / HttpServiceProxyFactory — even if the user never mentions a version (check the build file). Do NOT use for defining your OWN server endpoints (that is plain @RestController), for versioning endpoints you expose (see api-versioning), or for adding retries to the calls (see resilience).

Work with Jackson 3 JSON in Spring Boot 4 — the new tools.jackson packages, auto-configured JsonMapper, ISO-8601 date defaults, immutable builder config, and @JsonView hierarchies for response shaping. Use whenever a task in a Boot 4 project touches JSON serialization/deserialization config — customizing the mapper, date/enum formatting, filtering fields per endpoint, fixing com.fasterxml.jackson imports, or "different fields for summary vs detail" — even if the user never mentions a version (check the build file). Do NOT use for choosing REST client vs server code, or for Boot 3.x Jackson 2 setups (that is the legacy this replaces).

Send and receive JMS messages with the fluent JmsClient API (new in Spring Framework 7 / Boot 4) instead of JmsTemplate — covers basic send, QoS (priority/TTL/delay), custom headers, synchronous receive, receive-and-convert, and request-reply. Use when a task in a Boot 4 project involves JMS / message queues / ActiveMQ Artemis — producing or consuming messages, "send an order to a queue", RPC-over-JMS, or the user reaches for JmsTemplate — even if the user never mentions a version (check the build file). Do NOT use for Kafka or RabbitMQ/AMQP (different APIs), or for plain in-process events (use ApplicationEventPublisher).

Decide between MockMvcTester and RestTestClient for controller tests in Spring Framework 7, and use MockMvcTester's AssertJ-native server-side assertions. Use when a testing task in a Boot 4 / FW 7 project (check the build file — users rarely state the version) is a CHOICE between the two tools, or specifically wants MockMvcTester — AssertJ assertThat(...) on responses, handler/exception inspection, multipart/file-upload tests, or HttpServletRequest access. Do NOT use for a deep how-to on RestTestClient's bind modes (see rest-test-client) — this skill is the comparison + the MockMvcTester side.

Navigate Spring Boot 4's modular auto-configuration — the breaking change that split the monolithic spring-boot-autoconfigure JAR into focused modules, so features only auto-configure when their starter is present. Use when migrating Spring Boot 3.x → 4, choosing/adding starters, or debugging "it worked before and now it doesn't": missing auto-config, H2 console gone, RestClient/Flyway not wired, or the renamed spring-boot-starter-web → spring-boot-starter-webmvc. Also covers the spring-boot-autoconfigure-classic escape hatch. Do NOT use for writing your OWN @AutoConfiguration classes, or for runtime bean wiring (see bean-registration).

Apply JSpecify null-safety annotations in Spring Boot 4 / Spring Framework 7 — package-level @NullMarked plus @Nullable for the exceptions, giving compile-time/IDE null checking and clean Kotlin interop. Use whenever working on a Boot 4 / FW 7 codebase and the task touches null handling, NPE prevention, "should this be Optional", method/field nullability, package-info.java, or org.jspecify imports — even if the user doesn't say "JSpecify" or mention a version (check the build file). Do NOT use for general Optional API design unrelated to Boot 4, or for Spring's old org.springframework.lang.@Nullable (that is the legacy pattern this skill replaces).

Add production observability to Spring Boot 4 with the official spring-boot-starter-opentelemetry — automatic tracing of HTTP/JDBC, trace/span IDs in logs, and OTLP export to Grafana/Jaeger/Zipkin, plus @Observed for custom spans. Use when a task in a Boot 4 project is about observability/telemetry — tracing, distributed traces, metrics export, log-trace correlation, OpenTelemetry/OTLP, or wiring to an LGTM stack — even if the user never mentions a version (check the build file). Do NOT use for plain Actuator health/info endpoints, or for app logging config unrelated to trace correlation.

Add retries and concurrency limits with Spring Framework 7's BUILT-IN resilience — @Retryable (exponential backoff + jitter), @ConcurrencyLimit, and @EnableResilientMethods — no Spring Retry or Resilience4j dependency. Use when a task in a Boot 4 / FW 7 project needs fault tolerance — retry a flaky call, back off and re-try, limit concurrent executions of an expensive method, or the user reaches for spring-retry / @Recover / Resilience4j annotations — even if the user never mentions a version (check the build file). Do NOT use for circuit breakers, rate limiting, or bulkheads beyond simple concurrency caps (still Resilience4j territory), nor for HTTP-client timeouts/connection pools.

Test REST APIs with Spring Framework 7's RestTestClient — one fluent client for every level, via bindToController (unit), bindTo(MockMvc), bindToApplicationContext, bindToServer (E2E), and bindToRouterFunction. Use when writing or migrating tests for HTTP endpoints in a Boot 4 / FW 7 project (check the build file — users rarely state the version) and you want a single consistent API instead of switching between MockMvc, WebTestClient, and TestRestTemplate. Do NOT use when the user specifically wants AssertJ-style server-side assertions or to compare the two testing tools (see mock-vs-rest), nor for non-HTTP unit tests.

Enable and validate Spring Data AOT repositories in Spring Boot 4 — move query generation to build time for 50-70% faster startup, lower memory, and GraalVM-ready images, via the process-aot Maven goal. Use when a task in a Boot 4 project involves Spring Data repositories and startup performance, cold starts, native images, or build-time query validation, or when repository methods unexpectedly fall back to runtime reflection — even if the user never mentions a version (check the build file). Do NOT use for writing the query methods themselves (ordinary Spring Data derived/@Query work unchanged) or for non-repository AOT/native config.

Require multi-factor authentication in Spring Security 7 (Boot 4) with @EnableMultiFactorAuthentication — declare required factors (password + one-time token), let Spring route users through each, and plug in a custom OneTimeTokenService. Use when a task in a Boot 4 / Security 7 project involves MFA / 2FA / step-up auth, one-time tokens (OTT), magic links, or factor-based authorization — even if the user never mentions a version (check the build file). Do NOT use for basic single-factor form/HTTP-Basic login, OAuth2/OIDC client or resource-server setup, or method-level @PreAuthorize rules unrelated to factors.

Write a new blog post for Dan Vega's site — creates the file in content/blog/ with correct frontmatter and a complete first draft in Dan's voice. Use whenever the user wants to start, draft, scaffold, or create a new post/article — including phrasings like "new blog post", "write a post about X", "start an article on Y", "draft something on Z", or when they hand over a topic, a URL, or research notes and want them turned into a post. Scope is creating a NEW post; optimizing an existing one is `seo-optimize`, and finding what to write about next is `seo-opportunities`.

Find what to write or fix next on Dan Vega's blog, ranked by evidence from Google Search Console. Use when the user wants to: (1) find content opportunities or "what should I write about", (2) find keyword/traffic gaps, (3) find pages worth optimizing, (4) figure out where the traffic upside is, or when they mention "opportunities", "what to write", "content gap", "striking distance", "low CTR pages", or "where should I focus". This finds the work; `seo-optimize` does the work on a single post; `new-blog-post` scaffolds a new one.

SEO keyword research and optimization for an existing blog post on Dan Vega's site. Use when the user wants to: (1) find keywords for a finished blog post, (2) optimize a post for search engines, (3) research what developers search for on a topic, (4) improve or add the `keywords` frontmatter, or when they mention "SEO", "keywords", "optimize for search", or "make this rank better". Works on posts in content/blog/. Research is web-search based (no paid APIs). Scope is optimizing a post that already exists — not writing new posts (use new-blog-post for that).