Development skills

Diagnose Attio REST API failures using response status, structured error details, and endpoint documentation. Identify authentication, permission, validation, and rate-limit problems, then apply a minimal correction and verify it while keeping tokens and customer data out of diagnostic records.

• Investigate 401 and 403 authentication or permission errors
• Check request formats behind 400 and 422 errors
• Review retry handling for 429 responses

Design or review an AssemblyAI system for recorded audio jobs, live Streaming v3 sessions, and LLM Gateway analysis. Map services, credentials, queues, callbacks, retention, and deletion paths so the architecture makes data handling, costs, and operational boundaries visible.

• Planning an AssemblyAI audio processing pipeline
• Reviewing live and recorded transcription flows
• Mapping credentials, callbacks, and queues

Triage failures across AssemblyAI REST requests, transcripts, Streaming v3, webhooks, and LLM Gateway. Separate transport, authentication, quota, processing, and callback issues, then report a retry, input fix, capacity action, or escalation using content-free evidence.

• Investigating a failed or stalled transcript
• Separating streaming and webhook failures
• Preparing a safe error report without customer content

Analyze Attio integrations that hit request limits and design separate read and write budgets, controlled queues, and bounded retries. Produce a request control policy with load test evidence and clear rollback thresholds.

• Investigating bursts of Attio 429 errors
• Separating read and write request budgets
• Reviewing retry rules and queue delays

Prepare authenticated access to the AppFolio Stack API using provider-issued client credentials and HTTP Basic Auth. Set up a TypeScript REST client and verify connectivity with a safe read request, while keeping secrets out of source files and shared logs.

• Preparing AppFolio Stack API credentials
• Setting up a TypeScript client with Basic Auth
• Checking API access with a read-only request

Set up local development for AppFolio integrations using synthetic property, tenant, lease, and work-order data. Test validation, duplicate submissions, and error handling locally, then check an approved read through a separate managed sandbox workflow.

• Developing integrations with synthetic property and tenant data
• Testing work-order forms and duplicate submissions
• Iterating locally without consuming live API quota

Set up a local development loop for Apple Notes automation scripts, with file watching, automatic reruns, and test helpers. Use a dedicated test folder or a mock adapter to check note operations while editing.

• Set up automatic reruns while editing Notes scripts
• Check note operations in a dedicated test folder
• Run unit tests with a mock Notes adapter

Plan an AppFolio Stack API integration for property management, covering services, caches, queues, and reconciliation. The architecture addresses vacancy updates, tenant and lease data, work orders, and accounting sync, with staging checks for retries, duplicate events, rate limits, and rollback.

• Design an integration for a multi-property portfolio
• Plan vacancy and lease data synchronization
• Route maintenance work orders through a queue

Handle AppFolio property management notifications through a verified webhook flow. Check signed raw requests, persist events before acknowledging them, and process them asynchronously with durable duplicate protection so retries do not repeat tenant, lease, payment, or work-order effects.

• Receiving tenant or lease lifecycle notifications
• Syncing payment and work-order events
• Testing duplicate, malformed, or delayed webhook deliveries

Improve Apollo.io API performance with reusable connections, cached responses, bulk requests, and controlled parallel searches. Reduce unnecessary processing and memory use, then compare response times and result accuracy before adopting changes.

• Investigating slow Apollo.io searches
• Batching requests to add details to contact records
• Reducing memory use when processing search results

Update AppFolio integrations when API versions change. Check version differences, transform property and tenant fields, revise endpoint URLs and pagination, and verify core endpoints in staging with a fallback to the previous version.

• Upgrading a deprecated AppFolio API version
• Updating renamed property and tenant fields
• Adapting to a new pagination method

Check an initial AppFolio API connection using verified provider-issued client settings. Read an approved test property listing and tenant records, then report only property IDs and a tenant count without creating or updating records.

• Checking an initial AppFolio API connection
• Retrieving approved test property IDs
• Counting tenant records for a test property

Control AppFolio API request rates and retries during bulk synchronization. Use endpoint limits, server-specified waits, saved progress, and duplicate-write protection to determine when batches should resume, pause, or require operator review.

• Handling 429 errors during bulk synchronization
• Controlling request rates for nightly portfolio syncs
• Preventing duplicate writes after a lost response

Build Apollo.io integrations that detect contact changes through periodic API checks or third-party automation platforms. Sync updates to a CRM, monitor email engagement, and create follow-up tasks, with guidance for preventing duplicate processing and missed records.

• Sync Apollo contact changes to a CRM
• Automate actions when contact stages change
• Monitor email replies, opens, and bounces

Use this skill to update an Apollo.io API integration when endpoints, authentication, or API versions change. It helps inventory current calls, map deprecated patterns to replacements, compare responses using redacted fixtures, and identify leftover legacy usage.

• Finding deprecated Apollo API calls in a codebase
• Moving API keys from query parameters to headers
• Switching search calls to current endpoints

Diagnose common AppFolio Stack API integration failures, including authentication, portfolio URL, validation, rate-limit, and server errors. Get redacted troubleshooting guidance and bounded recovery steps that help avoid duplicate writes or exposing tenant and lease data.

• Diagnosing a tenant lookup that returns 404
• Handling API authentication or rate-limit errors
• Investigating lease conflicts and validation failures

Build and refactor Apollo.io API integrations in TypeScript using reusable client patterns. Add configuration validation, structured errors, controlled retries, paginated search retrieval, and batch contact enrichment to organize API access across a project.

• Building a reusable Apollo.io API client
• Standardizing error handling and retries
• Retrieving search results across multiple pages

Plan an Apollo.io integration with separate API, service, client, background job, and data layers. The examples cover lead search and enrichment, deal tracking, queued work, database models, and Express routes for a sales intelligence system.

• Designing a layered Apollo.io integration
• Searching for and enriching leads
• Managing deals and pipeline stages

Improve AppFolio API performance through caching, grouped requests, and reused connections. Compare response times and request counts before and after changes while checking that results remain complete, accurate, and sufficiently fresh.

• Investigating a slow property dashboard
• Reducing repeated property and unit requests
• Processing work orders in controlled batches

Control Apollo.io API request rates by endpoint, queue calls to limit bursts, and retry after 429 responses using Retry-After or exponential delays. Monitor response headers to spot high usage and keep bulk searches and enrichment requests within configured limits.

• Handling Apollo API 429 responses
• Adding retry and backoff behavior
• Limiting bursts in bulk API requests

Create a structured AppFolio REST API client for property management data such as properties, tenants, leases, and work orders. It centralizes credentials, typed responses, pagination, timeouts, and error handling, including deliberate handling of rate limits and uncertain write outcomes.

• Building an AppFolio API client
• Listing properties or tenants with pagination
• Handling API errors and rate limits

Set up a local development loop for Claude API projects with a reusable client, mock responses, request logging, and hot reload. Run routine tests without API calls, track model and token usage, and enable live requests deliberately when checking real API behavior.

• Set up a local Claude API project structure
• Test prompt changes with saved mock responses
• Reload the app automatically during development

Manage Claude API request and token budgets with coordinated rate controls. Handle 429 errors using response headers and bounded retries, and organize queued or batch work to fit available capacity across application instances.

• Adding retry handling for Claude API 429 errors
• Sharing request and token budgets across instances
• Queuing or batching large prompt workloads

Build an application layer that controls team access to Apollo.io APIs. It helps define role permissions, issue scoped and expiring API keys, route requests through an Express proxy, and provide administrative key and usage endpoints.

• Defining Apollo API permissions for team roles
• Issuing scoped, expiring keys for team members
• Routing Apollo requests through an Express permission check