Overview

This tutorial teaches you how to: (1) deploy or access GLM-5 for orchestration, (2) install & configure Claude Code for execution in your environment, (3) build a lightweight orchestration service that connects GLM-5 and Claude Code, and (4) test and harden the workflow.

AI-driven workflows are transforming how developers build and ship software. In our step-by-step tutorial on building an AI developer workflow with Claude Code and GLM-5 , you’ll learn how to automate coding tasks, improve efficiency, and create a scalable AI-powered development pipeline.

Prerequisites

Familiarity with Git, terminal/CLI, and basic Node.js or Python.
An environment with a repository to test against (local or VM).
Access to Claude Code (CLI or IDE integration) and permission to run it against the target repo.
GLM-5 access — either local container, community weights, or a hosted API.

High-level architecture

GLM-5 (planner): receives a developer goal and returns a JSON-structured task plan.
Orchestration service: forwards the plan to an execution agent, validates outputs, and loops back to GLM-5 for further steps.
Claude Code (executor): runs commands, edits files, runs tests, and provides structured results.

Step 0 — Safety & Permissions (do this first)

Run the system in a feature branch or sandbox repo before production.
Create a minimal policy file (e.g., `CLAUDE.md`) that lists allowed directories and commands.
Use ephemeral credentials and limit network access for the execution agent.

Always review proposed code changes manually or set the system to open a draft PR for human review before merging.

Step 1 — Install & configure Claude Code

Claude Code tooling differs by vendor and release. The pattern below uses a generic CLI placeholder `claude-code` — replace with the real CLI or SDK you have.

Install (example)

# Example: install CLI (replace with real installer)
curl -sSL https://example.com/install-claude-code.sh | bash
# or via package manager
# npm i -g claude-code-cli

Authenticate

# set a scoped token in env
export CLAUDE_CODE_API_KEY="your_scoped_token"
# or run interactive login
claude-code login --token $CLAUDE_CODE_API_KEY

Create a minimal CLAUDE.md

-- CLAUDE.md (example policy)
allowed_paths:
  - src/
  - tests/
allowed_commands:
  - npm test
  - pytest
  - git status
max_changes_per_run: 10

Save `CLAUDE.md` at repository root so the executor enforces limits.

Step 2 — Obtain GLM-5 and setup an orchestration endpoint

Options for GLM-5:

Hosted API (provider-managed)
Local container (run on a GPU machine or CPU instance for development)

Example: simple local GLM-5 HTTP shim (pseudo)

// Node.js minimal server that forwards prompts to GLM-5 local endpoint
const express = require('express');
const fetch = require('node-fetch');
const app = express();
app.use(express.json());

app.post('/plan', async (req, res) => {
  const prompt = req.body.prompt;
  // forward to your GLM-5 endpoint (replace URL)
  const glm = await fetch('http://localhost:8000/v1/generate', {
    method: 'POST',
    headers: {'Content-Type':'application/json'},
    body: JSON.stringify({prompt, max_tokens:800})
  });
  const data = await glm.json();
  res.json(data);
});
app.listen(3010, ()=>console.log('orchestrator:3010'));

Replace the fetch call with the real GLM-5 API payload for your deployment.

Step 3 — Prompt templates & structured planner responses

To reliably parse GLM-5 output, request a structured JSON plan. Example prompt:

{
  "instruction": "You are GLM-5. Given the goal, return a JSON array named tasks. Each task has id, description, command OR patch (diff), and success_criteria.",
  "goal": "Implement a health-check endpoint at /health that returns 200 and a JSON payload {\"status\":\"ok\"} and add unit tests."
}

Desired JSON response (example):

[
  {"id":1,"description":"Create endpoint","command":"apply_patch","patch":"+++ ...diff...","success_criteria":"/health returns 200"},
  {"id":2,"description":"Add tests","command":"apply_patch","patch":"+++ ...diff...","success_criteria":"unit tests pass"}
]

Make GLM-5 output strict JSON so your orchestrator can parse and run tasks deterministically.

Step 4 — Orchestration: run tasks and call Claude Code

Pattern: orchestrator receives plan > validates tasks > invokes Claude Code for execution > collects result > asks GLM-5 for next step.

Example orchestration loop (Node.js)

// simplified loop: runs one task at a time
const {exec} = require('child_process');
async function runTask(task){
  if(task.command === 'shell'){
    return new Promise((resolve)=>{
      exec(task.exec, {cwd: '/path/to/repo'}, (err, stdout, stderr)=>{
        resolve({ok: !err, stdout, stderr});
      });
    });
  }
  if(task.command === 'apply_patch'){
    // call Claude Code to apply a patch safely
    // placeholder: replace with real CLI/SDK invocation
    const patchPayload = task.patch;
    // write patch to temp and execute claude-code apply --patch file
  }
}
// after running, report results back to GLM-5 for re-planning

Use the real `claude-code` CLI/SDK to perform safe edits. Many setups support previewing diffs and opening draft PRs instead of direct commits.

Step 5 — Verification & iteration

For each task ensure you have explicit success criteria. After executing a subtask:

Run unit tests / lint / type checks.
Collect results and artifacts (test logs, diffs, console output).
Send results to GLM-5 with a short status prompt like: "Task X finished: pass/fail. Next step?"

// sample status payload to GLM-5
{ "task_id": 2, "status": "failed", "stderr": "Traceback: ..." }

Step 6 — CI integration & automation

CI can be used as a gate: require the orchestrator to open a draft PR, then run standard CI for full validation. Example flow:

Orchestrator applies changes to a feature branch and opens draft PR.
CI runs full test matrix and reports back.
GLM-5 analyzes CI results and suggests fixes or marks ready for review.

Example: end-to-end run (developer experience)

Developer: POST /orchestrator/run-goal {"goal":"Add a health endpoint"}
GLM-5 returns 3 ordered tasks in JSON.
Orchestrator executes Task 1 by calling Claude Code to create a file and run tests.
Tests fail; results returned to GLM-5.
GLM-5 updates plan; orchestrator applies fix via Claude Code.
Once tests pass, orchestrator opens a draft PR for human review.

Security, auditing & best practices

Limit execution scope via `CLAUDE.md` or similar policy enforcement.
Log every command, diff, and test result for auditability.
Use dry-run and preview modes by default; require manual approval for merges.
Rotate tokens, use ephemeral credentials for cloud resources, and avoid exposing secrets to models.

Troubleshooting

Parser errors from GLM-5: tighten the prompt and ask for strict JSON only.
Unexpected code edits: restrict allowed files and prefer draft PRs.
Slow iteration: reduce token budget, use smaller reasoning context for short tasks, and cache static repo snapshots.

Next steps & extensions

Add telemetry to measure time saved and failure rates.
Experiment with agent ensembles: multiple planners or validators.
Integrate code review automation for style and security checks.