defold-project-build
Builds the project using the running Defold editor, returns build errors, and launches the game if build succeeds.
Best use case
defold-project-build is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Builds the project using the running Defold editor, returns build errors, and launches the game if build succeeds.
Teams using defold-project-build should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/defold-project-build/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How defold-project-build Compares
| Feature / Agent | defold-project-build | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Builds the project using the running Defold editor, returns build errors, and launches the game if build succeeds.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Build Defold Project via Editor HTTP API
Build and run a Defold project by sending HTTP requests to the running Defold editor.
## Prerequisites
- The Defold editor must be running with the project open.
## Reading the Editor Port
The editor writes its HTTP port to `.internal/editor.port` in the project root. Read this file to get the port number.
**Windows (PowerShell):**
```powershell
$port = Get-Content .internal/editor.port
```
**Linux/macOS:**
```bash
port=$(cat .internal/editor.port)
```
If the file does not exist, the editor is not running or the project is not open.
## Building the Project
Send a POST request to the `/command/build` endpoint.
**Windows (PowerShell):**
```powershell
Invoke-RestMethod -Uri "http://127.0.0.1:$port/command/build" -Method Post
```
**Linux/macOS:**
```bash
curl -X POST "http://127.0.0.1:$port/command/build" --silent
```
The response is JSON with two fields:
- `success` (boolean) — whether the build succeeded.
- `issues` (array) — list of build issues (empty on success).
If `success` is `true`, the build succeeded and the editor launches the game automatically.
If `success` is `false`, each entry in `issues` contains:
| Field | Description |
|-------|-------------|
| `severity` | `"error"` or `"warning"` |
| `message` | Human-readable description |
| `resource` | Absolute project path (e.g. `/main/logo.script`) |
| `range.start.line` | Start line (0-based) |
| `range.start.character` | Start column (0-based) |
| `range.end.line` | End line (0-based) |
| `range.end.character` | End column (0-based) |
## Checking Console Output
After a successful build and launch, read runtime logs from the editor console:
**Windows (PowerShell):**
```powershell
Invoke-RestMethod -Uri "http://127.0.0.1:$port/console" -Method Get
```
**Linux/macOS:**
```bash
curl "http://127.0.0.1:$port/console" --silent
```
## Workflow
1. Read the port from `.internal/editor.port`.
2. POST to `/command/build`.
3. If the build fails, report all issues with file paths, line numbers, and messages.
4. If the build succeeds, the game launches automatically. Check `/console` for runtime logs if needed.
## Troubleshooting
- **Connection refused** — the editor is not running or the port file is stale. Restart the editor and try again.
## Example: Successful Build Response
```json
{
"success": true,
"issues": []
}
```
## Example: Failed Build Response
```json
{
"success": false,
"issues": [
{
"severity": "error",
"message": "go.property declaration should be a top-level statement",
"resource": "/main/logo.script",
"range": {
"start": { "line": 3, "character": 4 },
"end": { "line": 3, "character": 35 }
}
}
]
}
```Related Skills
vertex-agent-builder
Build and deploy production-ready generative AI agents using Vertex AI, Gemini models, and Google Cloud infrastructure with RAG, function calling, and multi-modal capabilities
test-data-builder
Test Data Builder - Auto-activating skill for Test Automation. Triggers on: test data builder, test data builder Part of the Test Automation skill category.
building-terraform-modules
This skill empowers Claude to build reusable Terraform modules based on user specifications. It leverages the terraform-module-builder plugin to generate production-ready, well-documented Terraform module code, incorporating best practices for security, scalability, and multi-platform support. Use this skill when the user requests to create a new Terraform module, generate Terraform configuration, or needs help structuring infrastructure as code using Terraform. The trigger terms include "create Terraform module," "generate Terraform configuration," "Terraform module code," and "infrastructure as code."
sklearn-pipeline-builder
Sklearn Pipeline Builder - Auto-activating skill for ML Training. Triggers on: sklearn pipeline builder, sklearn pipeline builder Part of the ML Training skill category.
sam-template-builder
Sam Template Builder - Auto-activating skill for AWS Skills. Triggers on: sam template builder, sam template builder Part of the AWS Skills skill category.
building-recommendation-systems
This skill empowers Claude to construct recommendation systems using collaborative filtering, content-based filtering, or hybrid approaches. It analyzes user preferences, item features, and interaction data to generate personalized recommendations. Use this skill when the user requests to build a recommendation engine, needs help with collaborative filtering, wants to implement content-based filtering, or seeks to rank items based on relevance for a specific user or group of users. It is triggered by requests involving "recommendations", "collaborative filtering", "content-based filtering", "ranking items", or "building a recommender".
prefect-flow-builder
Prefect Flow Builder - Auto-activating skill for Data Pipelines. Triggers on: prefect flow builder, prefect flow builder Part of the Data Pipelines skill category.
building-neural-networks
This skill allows Claude to construct and configure neural network architectures using the neural-network-builder plugin. It should be used when the user requests the creation of a new neural network, modification of an existing one, or assistance with defining the layers, parameters, and training process. The skill is triggered by requests involving terms like "build a neural network," "define network architecture," "configure layers," or specific mentions of neural network types (e.g., "CNN," "RNN," "transformer").
graphql-mutation-builder
Graphql Mutation Builder - Auto-activating skill for API Development. Triggers on: graphql mutation builder, graphql mutation builder Part of the API Development skill category.
building-gitops-workflows
This skill enables Claude to construct GitOps workflows using ArgoCD and Flux. It is designed to generate production-ready configurations, implement best practices, and ensure a security-first approach for Kubernetes deployments. Use this skill when the user explicitly requests "GitOps workflow", "ArgoCD", "Flux", or asks for help with setting up a continuous delivery pipeline using GitOps principles. The skill will generate the necessary configuration files and setup code based on the user's specific requirements and infrastructure.
github-project-setup
Github Project Setup - Auto-activating skill for Enterprise Workflows. Triggers on: github project setup, github project setup Part of the Enterprise Workflows skill category.
funnel-analysis-builder
Funnel Analysis Builder - Auto-activating skill for Data Analytics. Triggers on: funnel analysis builder, funnel analysis builder Part of the Data Analytics skill category.