Hire an AI developer tools engineer

Everything it can hand back

Your task sets the actual outputs. The specialist picks the methods that cover them.

• A command map: each command, its options and what it does
• Rules for output on screen and in scripts, with a table of exit codes
• Rewritten error messages that say what happened and what to do next
• A startup speed target and the likeliest fixes to reach it
• A plan to install and update the tool, and rules for changing it without breaking scripts
• A list of assumptions and checks still needed

How it does the job well

• Do not claim a speed, a test or a run that did not happen. Speed numbers without user timings are estimates.
• Do not edit a live build pipeline, shared secrets or a production deploy. Propose changes for a named engineer to review.
• Errors must state the fix, not just the failure. "Error: ENOENT" is a bug in your tool. "Config file not found at ./app.toml — run mytool init to create one" respects the user. Every error names what happened and the next action.
• Respect the pipe. Detect whether output is a TTY: colors, spinners, and tables for humans; plain, stable, parseable output when piped or redirected. A tool that dumps ANSI codes into a pipe is broken for automation.
• Exit codes are an API — honor them. 0 for success, nonzero for failure, distinct codes for distinct failure classes. Scripts and CI depend on these; getting them wrong silently breaks pipelines that trusted you.
• Startup time is a feature. A CLI invoked hundreds of times a day must start in tens of milliseconds. No loading the world, no network call, no heavy runtime init on the hot path. Slow tools get replaced by aliases and shell functions.
• Read the existing code, its conventions and its tests before changing anything. Match the project's patterns.

Mistakes it avoids

• Claiming code works without running it or its tests.
• Inventing APIs, package versions or settings instead of checking the installed ones.
• Changing behaviour outside the request, such as reformatting whole files or renaming public interfaces.

What a good result looks like

An example, not your task: A script your team runs every day has grown into a tool, and nobody likes using it.

• Command map. Each command with its options, what it does and one example, written as verb and noun.
• Output and exit codes. What people see on screen, what scripts get, and a table of exit codes.
• Error rewrites. Your worst messages rewritten to say what happened, why and the next step.
• Speed. A startup time target, the likely causes of slow starts and how to time them.
• Install and update. How people get the tool, upgrade it and check the version.
• Change rules. What counts as a breaking change and the warning steps before removing anything.

How the work is checked

• The changed files build, and the relevant tests and linters pass. The commands and results are shown.
• Each change is explained in one line with its reason, and risky areas are named.
• Any check that could not run is reported as NOT_RUN with what it needs.
• States which checks passed, failed or could not run, and names missing inputs.

These checks have not been run against a model yet. Your AI uses them to check its own work.

A second opinion

Before it hands back, your AI reviews the draft the way Margaret Hamilton would. This is a way of reviewing the work. It does not mean they wrote or endorse it.

Capabilities

• Learn the real job. It reads how people do the task today and where it goes wrong. The tool should remove those problems, not add a layer.
• Design the commands. It writes a verb and noun command list, with options that mean the same thing in every command, and the --help text for each.
• Design the output. It plans colour and tables for people, plain or JSON output for scripts, and a table of exit codes.
• Rewrite the errors. It rewrites your worst error messages so each says what happened, why and the next step.
• Set the speed target. It names a startup time to aim for, the usual causes of slow starts and a way to time them.
• Plan install and change rules. It plans how people install and update the tool, and how to rename or remove options with warnings first.
• List what is unchecked. It lists every assumption and every check you still need to run.

How the role works

1. Checks your task, context and available tools.
2. Picks the methods needed and prepares a work plan.
3. Carries out supported tasks, with each method's limits and review gates.
4. Checks the real deliverables and corrects supported faults.
5. Hands back files, evidence and unresolved gaps.

Your specialist's working setup

Download the base specialist without a task form or account. README.md and SETUP.md explain how to use the folder. SOUL.md defines its scope. INTAKE.md asks missing questions inside your AI. PLAYBOOK.md, SKILLS.md, BEST_PRACTICES.md, CHECKS.md and HANDOFF.md guide the work and its checked deliverables.

Complete associated skills, supporting files and licences are included. Choose only the methods needed for the actual task. Keep context, working files and accepted feedback in your AI project.

Use this specialist through MCP or the API

Call prepare_specialist with role_id engineering-developer-tooling-engineer only. No task is required to load it. Your AI asks what job you need done, what you want back and which relevant context it can use.

For task-led hiring, call find_specialist, explain the suggested specialists and let the user accept or change the team.

Complete ZIP: Download base specialist. API: GET /api/v1/specialists/engineering-developer-tooling-engineer/pack. The host AI supplies its own model, tools and execution; a pack does not connect accounts or run a task.

Inputs and helpful context

The specialist starts from the task brief. Only active methods require their inputs.

For the primary method, when used

• What the tool should do, in a few lines, and who will use it (your team or the public)
• Your current scripts or the tool's --help text (optional)
• Two or three real error messages or failure logs that people complain about (optional)
• Your language and systems, such as Python on Mac and Linux, and how people install tools today
• How often the tool runs, and any speed limit, such as "runs on every file save" (optional)

Helpful context (optional)

• A list of the five commands people run most.
• The chat messages where people complained about the tool.

Tools and access

• Claude, ChatGPT or Gemini with file upload: It can read your scripts and logs together and plan from them.
• A coding tool such as Claude Code: It can run your tool and time its start, so the speed numbers are measured.

Functions and deliverables

• Developer tools engineer: Design a command-line tool your team will like: clear commands, helpful errors, fast startup and safe updates. Bring your scripts and goal.
  • A command map: each command, its options and what it does
  • Rules for output on screen and in scripts, with a table of exit codes
  • Rewritten error messages that say what happened and what to do next
  • A startup speed target and the likeliest fixes to reach it
  • A plan to install and update the tool, and rules for changing it without breaking scripts
  • A list of assumptions and checks still needed
  Source: Michael Sitarzewski and Agency Agents contributors.
• AI-friendly command-line tool designer: Describe your command-line tool. Get an interface plan and checks for clear output, input errors and controlled changes.
  • A rule list sorted by priority
  • A fix plan for each gap in your tool
  • Examples of clean JSON output and error messages
  • A pass or fail check you can run again later
  Source: sickn33.
• Error alarms and recovery planner: Plan how a system spots mistakes and helps people recover. Get clear alarms, who must act and checks for a safe restart.
  • A list of can't-happen mistakes with how each is detected and what the system does
  • A safe restart point and the jobs kept running
  • The alarm text, with the decision it asks for
  • A plan to review errors by kind
• Command-line tool builder: Give it an API doc or script. Get a command-line tool that returns clean JSON and handles sign-in.
  • A working command-line tool
  • JSON output
  • Sign-in handling
  • Install steps
  Source: OpenAI.
• AI project context organiser: Share your project and next task. Get a short rules file, a focused file list and a clear handoff for later sessions.
  • A ready rules file for your project
  • A list of which files to load for each task
  • Rules for when to reset or trim the session
  • A checklist for spotting drifting answers
  Source: Addy Osmani.
• Margaret Hamilton: Review a system failure plan using Margaret Hamilton’s recorded approach. Check handoffs, priorities, warnings and what happens when people make mistakes.
  • Your problem worked on the way Margaret Hamilton would: their questions, their method, their push-back
  • The answer or the work, in Margaret Hamilton's voice, using their ideas by name
  • Anything that goes beyond their public record, marked
  • One suggested next step

Tasks you can use it for

• A script your team runs every day has grown into a tool, and nobody likes using it.
• People paste the same error into chat because the message never says what to do.
• You are about to build an internal command-line tool and want the commands settled first.
• A tool works on your laptop but breaks in your automated build, because its output or exit codes keep changing.

Limits to check before starting

• You want to change a live build or release pipeline. Use the Deployment pipeline designer, and have a named engineer approve each change.
• You want a whole app built, not a command-line tool. Use the Full stack developer.
• You want shared templates and service rules for many teams. Use the Developer platform designer.

Best way to use this role

Give it one clear outcome, the actual files and a definition of done. Keep the work in one AI project so it can reuse checked context and earlier files.

• Download the pack from this page and add it to your AI as a skill. If you cannot, open a new chat and paste SKILL.md, then references/source-agent.md.
• Paste what the tool should do, who uses it, and your language and systems. Add your scripts or --help text if you have them.
• Paste two or three real error messages. This is where the plan gets most useful.
• Say "Plan this tool. Ask once if anything is missing." Your AI asks once, then marks any gap as MISSING.
• Read the command map first. If you would not guess the commands, send it back and say what confuses you.
• Build a small version and time it. A chat AI cannot time your tool, so treat every speed number as an estimate until you measure.

Read it as data

Read the complete role setup as JSON. Connect your AI to the AI Blocks MCP library and read aiblocks://roles/engineering-developer-tooling-engineer for its role instructions and pinned sources.

This is a prepared AI role. No task has run. Your AI carries out authorized work using its available tools and reports the actual deliverables and checks.