Results for “program”

Designs, reconciles, and reviews an end-to-end Drydock program for safely staging agent runtimes: immutable worktree provenance, disposable VM containment, typed effect brokerage, global body accounting, resurrection, subscription-capacity economics, context compaction, operator control, evidence, and promotion. Use when several Drydock contracts must compose into one architecture, implementation hypertree, diagram set, or release plan. NOT for launching Port Daddy, running an untrusted subject, replacing focused containment/resurrection/capacity audits, or treating a design packet as runtime authority.

The English summary is being prepared. Showing the original description.

Programmatic SEO planning and analysis for pages generated at scale from data sources. Covers template engines, URL patterns, internal linking automation, thin content safeguards, and index bloat prevention. Use when user says "programmatic SEO", "pages at scale", "dynamic pages", "template pages", "generated pages", or "data-driven SEO".

The English summary is being prepared. Showing the original description.

Build and scale developer-led adoption through ecosystem programs. Use when deciding open vs curated ecosystems, building developer programs, scaling platform adoption, or designing student program pipelines.

The English summary is being prepared. Showing the original description.

Parses and analyzes the Windows Amcache.hve registry hive to extract evidence of program execution, application installation, and driver loading for digital forensics investigations. Uses Eric Zimmerman's AmcacheParser and Timeline Explorer for artifact extraction, SHA-1 hash correlation with threat intel, and timeline reconstruction. Activates for requests involving Amcache forensics, program execution evidence, Windows artifact analysis, or application compatibility cache investigation.

The English summary is being prepared. Showing the original description.

Plan and blueprint programmatic SEO page strategies at scale

The English summary is being prepared. Showing the original description.

Investigate Python bugs by pausing execution, inspecting variables, and stepping through code. Choose between local debugging with pdb or breakpoint(), exception inspection, and connecting debugpy to remote or already running processes.

• Inspecting variables in a failing Python test
• Tracing unexpected changes to program state
• Examining program state after an exception

Inspect and control interactive command-line programs running in tmux, a terminal session manager. List sessions and panes, capture current output or history, send text and special keys, and watch for prompts or completion markers.

• Inspect output from an interactive terminal program
• Send text or special keys to a running session
• Monitor input prompts and command completion

Create a pre-launch landing page with a brand logo, product message, and email signup form. Follow DESIGN.md for colors, fonts, and layout, producing a single HTML file with mobile layouts and form validation.

• Create an email waitlist page before a product launch
• Build a signup page for beta participants
• Collect interest in an early access program

Create videos programmatically with React for branded explainers, short social clips, and dashboard visuals. Use code to define motion graphics that can be reproduced through the same workflow.

• Creating branded explainer videos
• Producing short videos for social media
• Turning dashboards into videos

Create generative art, or images made with programmed rules, using p5.js. Fixed random seeds make each rendering reproducible, supporting procedural posters, still images that suggest motion, and studies of artistic frame composition.

• Posters generated with programmed rules
• Still images that suggest motion
• Studies of artistic frame composition

Work with AI as a coding partner, choosing who writes code and who guides the work. Supports role switching, test generation, ongoing code review, debugging, and step-by-step explanations for learning.

• Write code with ongoing AI review
• Direct AI implementation while reviewing its output
• Develop features by writing tests first

Get a detailed explanation of a file, function, or module using an existing knowledge graph and its source code. It explains architectural roles, dependencies, callers, and data flow for readers who may not know the programming language.

• Understand the role of a specific file
• Trace a function’s callers and dependencies
• Follow inputs, processing, and outputs

Turn specifications into pseudocode, a language-independent outline of program logic. Define data structures, handle edge cases, analyze time and memory requirements, and document design patterns and optimization opportunities before implementation.

• Turning specifications into clear processing steps
• Comparing data structures and computational costs
• Planning error handling and edge cases before coding

Work with AI as a coding partner, choosing who writes code and who guides the work. Supports role switching, test generation, ongoing code review, debugging, and step-by-step explanations for learning.

• Write code with ongoing AI review
• Direct AI implementation while reviewing its output
• Develop features by writing tests first

Add support for a programming language to codegraph, from connecting its parser and implementing code extraction to writing tests. Evaluate extraction quality and compare agent effort with and without codegraph across three real codebases.

• Adding a new programming language to codegraph
• Testing extraction of functions, imports, and calls
• Comparing agent effort across three real codebases

Test changes interactively in Codex's terminal interface. The skill explains how to launch it, save detailed logs for debugging, and send test messages programmatically with text and Enter submitted separately.

• Check changes in the Codex terminal interface
• Save detailed logs for debugging
• Send test messages programmatically

Debug programs with LLDB while keeping session state across commands. Set breakpoints, inspect variables and memory, and examine core dumps, with JSON results for agents and a debug adapter interface for editor clients.

• Inspect variables where a program stops
• Investigate a crash using a core dump
• Debug a running process

Plan large sets of search-focused pages using templates and data. The skill helps assess keyword demand, design useful page variations, organize internal links, choose a publishing platform, and check quality before launch.

• Planning service pages for different locations
• Designing comparison page templates
• Building a directory from existing data

Plan product listings across startup, SaaS, AI, and MCP directories. Assess launch readiness, choose relevant sites, prepare tailored descriptions, and track submissions, published links, and referral results in a structured workflow.

• Planning directory listings for a product launch
• Tailoring descriptions to different directory audiences
• Preparing an MCP server registry submission

Create product demos, explainers, and social clips by choosing among AI footage, virtual presenters, code-based video templates, and editing tools. The skill guides scripts, visuals, captions, reusable production workflows, and exports suited to the target platform.

• Creating a product demo with screen recordings and captions
• Producing an explainer with an AI presenter
• Generating multiple social clips from one template

Convert existing scripts, CLI tools, or Crawlee projects into reusable Apify Actors, programs packaged as Docker images. Define JSON inputs and outputs, integrate the SDK, test locally, and deploy to Apify.

• Turning an existing script or CLI tool into an Actor
• Migrating a Crawlee project to Apify
• Defining JSON inputs and structured outputs

Plan A/B tests to compare page or messaging changes. Helps define hypotheses, choose success metrics, estimate sample sizes, allocate traffic, and interpret results, while also organizing a repeatable process for prioritizing and documenting experiments.

• Compare headline or button-copy variants
• Plan sample sizes and test duration around available traffic
• Analyze results alongside metrics that must not worsen

Analyze a custom protocol in a CTF sandbox and reproduce an accepted exchange. Recover message boundaries, checksums, and session state, then build a small replay program that preserves the required message order.

• Recover message boundaries in an unknown protocol
• Reconstruct handshake steps and session state
• Build a replay program for a captured exchange

Inspect compiled programs in Binary Ninja using strings, function references, and intermediate representations—views of program logic at different levels. Trace data flow and report findings with addresses, supporting evidence, confidence, and reproduction steps.

• Tracing function calls and data flow in Binary Ninja
• Cross-checking findings from other disassemblers
• Automating binary analysis with the Python API