dnanexus-integration

Overview of dnanexus-integration skill

dnanexus-integration is a practical skill for working with the DNAnexus cloud genomics platform when you need more than a generic prompt. It helps with app and applet development, data upload and download, workflow execution, and dxpy-based automation for genomics pipelines.

Who this dnanexus-integration skill is for

Use this dnanexus-integration skill if you are building or maintaining Backend Development automation around DNAnexus: Python scripts, pipeline wrappers, app configuration, or job orchestration. It is most useful when your task touches files such as FASTQ, BAM, or VCF, or when you need platform-specific behavior that ordinary code assistance often misses.

What it helps you get done

The main job-to-be-done is turning a rough platform task into a workable DNAnexus implementation: create an app/applet, define inputs and outputs, run jobs, manage projects, and interact with data objects safely. The dnanexus-integration guide is especially relevant when you need to preserve DNAnexus conventions instead of inventing your own workflow.

Why this skill is different

The repo is organized around real operating areas: app development, configuration, data operations, job execution, and the Python SDK. That structure matters because DNAnexus work tends to fail on details such as dxapp.json shape, input linking, execution context, or the distinction between applets and apps. The dnanexus-integration skill is valuable when those details affect whether the solution will actually run.

How to Use dnanexus-integration skill

Install and load the skill

For a local skills workflow, install with:

npx skills add K-Dense-AI/claude-scientific-skills --skill dnanexus-integration

Then open SKILL.md first, because it defines the intended scope and points to the reference files that carry the actual working guidance. If you are using the dnanexus-integration install as part of a larger repo, keep the skill alongside your project context so it can adapt to your own folder structure and deployment constraints.

Start with the right input shape

The best dnanexus-integration usage begins with a specific task, not a broad request like “help me with DNAnexus.” Give the model the object type, language, and target outcome:

• “Create a DNAnexus applet in Python that accepts a BAM file and a minimum mapping quality, then outputs a filtered BAM.”
• “Write the dxapp.json inputs and runSpec for a Bash app that downloads a FASTQ, runs QC, and uploads results.”
• “Show how to launch a workflow job with linked inputs using dxpy.”

That level of detail improves output quality because DNAnexus behavior depends on execution model, file linking, and deployment format.

Read these files first

For most users, the fastest path is:

1. SKILL.md for scope and when-to-use guidance
2. references/app-development.md for build structure and applet/app patterns
3. references/configuration.md for dxapp.json, metadata, and dependencies
4. references/data-operations.md for file, record, and object handling
5. references/job-execution.md for running and monitoring jobs
6. references/python-sdk.md for dxpy installation and API usage

If you are blocked, read the file that matches the failure point: config for build errors, job execution for runtime issues, data operations for object handling.

Practical workflow for better results

Use dnanexus-integration like an implementation assistant:

1. Describe the platform object you are creating or modifying.
2. State whether you need an applet, app, script, or dxpy snippet.
3. Provide the expected inputs, outputs, and file types.
4. Mention whether you need local development, platform execution, or both.
5. Ask for the smallest working version first, then expand it.

That workflow reduces guesswork and makes the resulting prompt easier to verify against DNAnexus conventions.

dnanexus-integration skill FAQ

Is dnanexus-integration only for genomics work?

Mostly yes. The repository is centered on DNAnexus cloud genomics and bioinformatics workflows, so it fits best for pipeline development, file operations, and platform automation in that ecosystem.

Do I need DNAnexus experience to use it?

No, but basic familiarity helps. Beginners can still use the dnanexus-integration skill if they provide a concrete goal and file type. The skill is less helpful when the request is vague or when the user does not know whether they need an applet, an app, or a script.

Why use this instead of a normal prompt?

A normal prompt can draft code, but dnanexus-integration is better when the task depends on platform-specific rules: dxapp.json, dxpy, project and folder handling, applet vs app behavior, and job launching conventions. That makes it more reliable for Backend Development tasks that must run on DNAnexus.

When should I not use it?

Do not use dnanexus-integration if your task is unrelated to DNAnexus, if you only need generic Python advice, or if you are working on local-only data processing with no platform execution requirements. In those cases, a general coding prompt will be faster.

How to Improve dnanexus-integration skill

Give the model the missing DNAnexus details

The biggest improvement comes from specifying what the repository does not infer on its own: file types, input names, output locations, execution language, and whether the job runs on the platform or from an external script. For dnanexus-integration usage, “a workflow that processes VCF files” is weaker than “a Python applet that takes a VCF, a sample name, and a Boolean flag, then writes results to /out.”

Watch for the common failure modes

Most bad outputs come from underspecified execution assumptions: linking inputs incorrectly, mixing up applets and apps, omitting dxapp.json fields, or writing code that ignores DNAnexus object lifecycles. If the first answer seems generic, ask the dnanexus-integration guide to narrow to one file path or one job step at a time.

Iterate from skeleton to production

A strong improvement loop is:

• first ask for the minimal working app or dxpy example,
• then request validation of inputs and outputs,
• then add dependencies, container settings, or project handling,
• finally ask for deployment or test guidance.

This is usually better than asking for a full end-to-end pipeline in one shot, because DNAnexus failures are often configuration-driven rather than algorithm-driven.

Use repo files as checkpoints

If the generated answer is close but not deployable, compare it against references/configuration.md and references/job-execution.md before editing. Those files are the fastest way to catch mismatched metadata, incorrect run specifications, or unsafe assumptions about job state, which is what most users care about when deciding whether dnanexus-integration will work for their Backend Development task.