application-sdk

Bump a v3 app to the latest application-sdk and adopt the SDK-native preflight gate safely. The gate runs the app's preflight_check handler as the mandatory first activity of every extraction workflow and always reports the verdict; by default it is soft (a NOT_READY verdict is reported but the run proceeds), and blocking real runs on NOT_READY is a per-app opt-in (preflight_gate_mode = "hard"). Classifies the app's rollout bucket, fixes name collisions, audits the handler's status logic against the new semantics, runs an interactive check-design session with the developer (visualized as a decision tree: which checks block, which are advisory, what is missing), hunts for hidden preflight logic by behavior (not name) and consolidates it into the handler so both surfaces run one implementation, adopts typed check errors, and updates tests. Interactive: every blocking/advisory/consolidation decision belongs to the developer; the skill proposes, never imposes.

Create or audit-and-refresh the canonical capability manifest for application-sdk — a single scannable document listing every public symbol (import path, signature, docstring summary) plus every typed Input/Output contract. Run when starting a new agent task that needs a fast picture of what the SDK exposes, when SDK code has changed, or on a 30-day cadence.

Drive the conformance remediation loop: detect violations, propose and verify fixes, and emit a residue report for anything that needs human review. Runs the conformance suite (deterministic) to detect violations, uses the model to propose fixes, re-runs the suite to verify each fix, and loops until the gate is clean or the attempt cap is reached. Never games its own gate — source fixes are verified by re-detection; logic fixes are also verified by the orthogonal test gate. Backed by the OpenProse program shipped in the atlan-application-sdk-conformance package (resolve it with `programs-dir`). Run with the OpenProse skill to use the full Reactor-ready contract semantics; or invoke the program directly via the instructions below.

Drive an already-open PR to merge-ready: fix CI failures, resolve GitHub Copilot review comments, then loop @sdk-review (mothership) — fixing every finding it reports, including nits — until it comes back clean.

Good investigations depend on good signals. Use this skill to improve the quality of observability in a Python codebase — surfacing failures that are currently hidden, and removing noise that buries the signals you need. Errors swallowed silently, stack traces discarded, log output that can't be queried, credentials leaking into logs, INFO-level chatter drowning out what matters: all of these slow down debugging and erode trust in your observability stack. Standardising log levels means DEBUG stays out of production, INFO marks genuine lifecycle events, and ERROR only fires when something actually failed — so when you filter to WARNING or above during an incident, you see exactly what you need and nothing you don't. Run this before an incident review, before onboarding a service, or any time investigations feel harder than they should.

Convert an app's untyped exceptions (ValueError, RuntimeError, bare Exception, ActivityError) to SDK-typed AppError subclasses so every classified failure carries category / code / audience / retryable on the wire. The Automation Engine attributes failures from those typed fields without parsing exception strings. Interactive and incremental: surveys the app first, asks the developer to confirm categories at ambiguous sites, applies edits one batch at a time, then reports remaining blind-spot (silent-swallow) sites as a phase-2 punch list for owner approval.

Expert guidance for implementing incremental metadata extraction in a new SQL-based connector app using the Application SDK. Covers the full implementation: activities class (build_incremental_column_sql, SQL placeholders, fetch overrides), workflow class, SQL templates (extract_table_incremental.sql, extract_column_incremental.sql), Pydantic models, DuckDB integration, state management, and testing patterns. Use when adding incremental extraction to a new database connector or understanding the SDK's incremental extraction architecture.

One-shot local development bootstrap. Ensures Dapr + Temporal are running, generates .env from .env.example if absent, and runs the app in combined mode via run_dev_combined(). Diagnoses and fixes common startup failures.

Orchestrates adding incremental extraction to any Atlan connector app. Handles both SQL connectors (delegates to SDK's implement-incremental-extraction skill) and REST/GraphQL connectors (uses the Tableau pattern as reference). Runs as isolated sub-agents: reconnaissance -> feasibility -> implementation (branched by type) -> metrics -> test design -> test implementation -> iterative test-fix loop. Trigger with "Add incremental extraction to @atlan/<connector>".

Add a new @entrypoint method to an existing App subclass. Creates the typed Input/Output contracts, wires up tasks, and generates the per-entry-point manifest subfolder in app/generated/ if contracts are PKL-driven.

Create, migrate, update, generate, or validate Atlan native app Pkl contracts with app-contract-toolkit and the Atlan CLI. Use when an agent is helping an app author produce contract/app.pkl, contract/PklProject, app/generated artifacts, atlan.yaml decisions, SDK input contracts, and contract validation.

Upgrade a connector repo from application-sdk v2 to v3 — runs the import rewriter, performs AI-assisted structural refactoring, and validates the result with the upgrade checker.

Use when reviewing an application-sdk PR that changes contract-toolkit behavior, generated contract artifacts, toolkit examples, or toolkit docs. Runs toolkit-only PR review mode: classify affected generated surfaces, perform mandatory private downstream compatibility validation through Mothership/Rover, and post sanitized review findings without exposing internal consumer repo paths.

Create, migrate, update, generate, or validate Atlan native app Pkl contracts with app-contract-toolkit and the Atlan CLI. Use when an agent is helping an app author produce contract/app.pkl, contract/PklProject, app/generated artifacts, atlan.yaml decisions, SDK input contracts, and contract validation.

Audit every github.com/atlanhq/ consumer of application_sdk against a user-supplied check specification. Discovers consumer repos via `gh search code`, applies one or more named checks per repo (grep patterns anchored to SDK symbol usage), and produces a markdown report — including a coverage table listing every analyzed repo with its outcome (no-usage / no-findings / has-findings). Optionally raises migration PRs against consumer repos with confirmed findings. Use when proposing an SDK breaking change, removing a deprecated symbol, or proactively measuring the blast radius of a refactor before merging.

Expose existing @task methods as MCP tools. Adds @mcp_tool decorator, installs the mcp extra, sets ENABLE_MCP=true, and verifies the /mcp endpoint is reachable.

[v2-only] Migrate a v2 connector app from Argo to native orchestration. For v3 migrations, use /upgrade-v3.

Guide for creating the marketplace-packages branch and PRs to enable incremental extraction for a connector. Covers branching strategy (1 branch, 3 PRs to preprod/master/main with consistent titles), YAML template modifications for incremental parameters, interim app workflow steps, and temporary publish workarounds. Based on the Oracle incremental extraction PR pattern (PR #22199).