Nick

Coordinate specialist agents to investigate and improve application performance across databases, backend services, frontend code, and delivery infrastructure. Establish baseline measurements, address observed bottlenecks, validate changes with load tests, and set up monitoring to detect future slowdowns.

• Finding bottlenecks across an entire application
• Coordinating database, backend, and frontend improvements
• Validating performance changes with load tests

Build vector search that considers both semantic similarity and patterns in how items connect. Use graph features to explore structure in embeddings, numerical representations of content, and compare retrieval results with conventional similarity search.

• Investigate structure missed by cosine similarity
• Include contextual roles in RAG retrieval
• Compare graph-based and cosine search results

Document major technical choices as Architecture Decision Records, or ADRs. Capture the context, alternatives, reasons, and consequences, then organize related records and track whether decisions are proposed, accepted, retired, or replaced.

• Recording reasons for choosing a framework or database
• Comparing design options and their trade-offs
• Sharing past decisions with new team members

Ask GitHub Copilot for code explanations, reviews, or short code examples through its command line interface. The skill supports requests without an interactive screen and named sessions for follow-up questions.

• Getting a second opinion on code
• Reviewing an approved code excerpt
• Requesting a short code example

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

Add Application Insights monitoring to browser apps to record page views, clicks, network requests, and errors. Also covers custom measurements and tracing generative AI operations across browser and backend code to investigate behavior and performance.

• Monitoring page views and clicks in a browser app
• Recording network requests and application errors
• Linking browser activity to backend traces

Assess REST and GraphQL API security through checks of authentication, access permissions, input validation, and request limits. The workflow guides endpoint discovery, testing, and documentation of findings and remediation within an authorized scope.

• Checking API authentication and token handling
• Testing access permissions across roles and tenants
• Reviewing request limits and input validation

Review a repository’s architecture using Ontoly Software Graph, a map of code relationships. Explain module boundaries, package structure, dependencies, and architectural risks, with graph evidence and a stated confidence level.

• Understanding a repository’s overall architecture
• Reviewing module boundaries and package structure
• Investigating dependency cycles and architectural risks

Choose between REST, GraphQL, and tRPC based on who uses an API and how it is deployed. Define consistent responses, pagination, authentication, and versioning, supported by concrete request examples and failure cases.

• Choose an API style for known clients
• Standardize response and error formats
• Design pagination for changing data

Improve mobile app listings on Apple App Store and Google Play Store through keyword research, competitor and review analysis, and listing revisions. Produce metadata suggestions, visual asset guidance, A/B test plans, and launch checklists.

• Researching app keywords and competitors
• Revising store titles and descriptions
• Extracting complaints and feature requests from reviews

Build and manage Linux containers on Apple silicon Macs with Apple's container CLI. Run each container in its own lightweight virtual machine, and get guidance on images, networking, storage, and translating familiar Docker workflows to this tool.

• Building container images from a Dockerfile
• Running Linux containers on an Apple silicon Mac
• Managing persistent volumes and container networks

Create Appium tests that automate Android and iOS app interactions in Java, Python, or JavaScript. Configure local devices, emulators, simulators, or TestMu AI cloud devices, with guidance on element selection, waits, and gestures.

• Automate login tests for Android and iOS apps
• Create tests for local emulators and simulators
• Configure real-device tests on TestMu AI cloud

Turn git changes since the last tag into clear App Store release notes. Identifies updates users will notice, groups new features, improvements, and fixes, removes internal work and duplicates, and checks each bullet against the actual changes.

• Drafting App Store What's New text for a release
• Turning technical commits into plain release notes
• Collecting user-visible changes between specified tags

Guide an authorized Android security assessment from app inventory and APK acquisition to decompilation, embedded secret checks, exposed component review, runtime inspection, and network traffic analysis. The skill provides documentation and examples rather than bundled executable helpers.

• Inventory Android apps within an authorized scope
• Check APKs for embedded secrets and internal URLs
• Review exposed components and Firebase configuration

Create output schemas, definitions of result fields and display settings, for an Apify Actor by inspecting its source code. Generate dataset and output files, add key-value storage definitions when needed, and update actor.json to reference them.

• Creating output schemas for a new Actor
• Updating schemas after output fields change
• Configuring result table columns in Apify Console

Collect product details, prices, stock information, and customer reviews from supported online stores using Apify. Compare competitors, examine recurring quality complaints, discover sellers through Google Shopping, and export results as CSV or JSON.

• Monitor prices and compare competing products
• Analyze reviews for recurring quality issues
• Find sellers across stores through Google Shopping

Build and debug Apify Actors, cloud programs for web scraping, automation, and data processing. Get guidance on language templates, input and output schemas, runtime code, local testing, and deployment, with practices for handling credentials and external data.

• Creating an Actor for web scraping
• Defining Actor inputs and structured outputs
• Debugging an Actor with local test data

Turn article ideas into hand-drawn, 16:9 illustrations featuring Grav, a floating character. Plan image placement and visual metaphors, then generate white-background sketches with sparse English labels and review their consistency.

• Plan illustrations for a blog post
• Explain an abstract concept through a visual metaphor
• Keep illustration styles consistent across articles

Define and deploy Azure infrastructure with ARM templates and Bicep, languages for describing cloud resources in files. Get guidance on reusable modules, resource dependencies, environment parameters, and previewing deployment changes before applying them.

• Defining Azure networks and virtual machines in code
• Sharing modules across development and production
• Previewing infrastructure changes with What-If

Implement controlled retries and request throttling for external APIs. Covers retryable errors, provider-specified waiting times, increasing delays with random variation, retry limits, and checks that repeating a request will not cause unintended duplicate changes.

• Handle 429 and temporary server errors
• Respect Retry-After waiting times
• Limit outgoing API request frequency

Find which companion skill to use next and in what order. This guide maps ideas, prototypes, requirements, issues, implementation, and session handoffs into practical workflows based on the current development situation.

• Choose a starting point for a development idea
• Plan a build spanning multiple sessions
• Find a workflow for incoming bug reports

Implement and review API security within an application's existing authentication and data model. Covers token verification, resource permissions, input validation, request limits, secrets, and logging, with concrete checks for unauthorized access and invalid requests.

• Add authentication and permissions to an API endpoint
• Check access across users and tenant organizations
• Validate request inputs and reject extra fields

Clarify ambiguous requests before implementation by asking a small set of essential questions. Use concise choices and suggested defaults to agree on goals, scope, constraints, and completion criteria before starting work that depends on those answers.

• Clarify a request with several plausible interpretations
• Agree on completion criteria before implementation
• Confirm compatibility requirements and scope

Review the journey from discovering an API to receiving the first successful response. Identify delays in signup, authentication, setup, and documentation, then plan improvements using test environments, interactive examples, clearer errors, and measurements of progress.

• Auditing the path to a first successful API call
• Simplifying signup and access to test API keys
• Planning sandbox environments and interactive documentation