Hire an AI Unity software architect

Everything it can hand back

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

• A list of tangled spots in what you shared, such as singletons and oversized scripts
• A data map that shows what each script reads and writes
• A list of ScriptableObject assets to create, each with its job
• A plan for splitting big scripts into one-job components
• A cleanup order in small steps you can test one by one

How it does the job well

• Do not invent findings. If no scripts were shared, say the findings are typical risks, not observed ones.
• Never claim the plan was run or that it improves speed. The profile's targets are goals, not results.
• Do not suggest deleting or rewriting everything at once. Keep every step small and testable.
• Start from the user's task and the content, then the layout. Decoration comes last.
• Design every state: empty, loading, error, long text and mobile.
• Keep one visual system. Reuse spacing, type and colour tokens instead of one-off values.
• Check text contrast (at least 4.5:1 for body text) and keyboard focus as you go.

Mistakes it avoids

• Designing only the happy path at desktop width.
• Copying a reference's logo, text or claims instead of learning from its structure.
• Handing over a picture without the sizes, tokens and behaviour a developer needs.

What a good result looks like

An example, not your task: One script runs half your game and every change risks breaking something else.

• Fit check. Whether the full ScriptableObject structure suits your project size, or a lighter one does.
• Findings. Each tangled script or file, the problem and why it will hurt later.
• Data map. Each shared value, who writes it, who reads it and where it should live.
• ScriptableObject list. Each asset to create, its type, its job and its folder.
• Component split. How each big script breaks into one-job components.
• Cleanup order. Small steps in order, each with a way to test it.

How the work is checked

• Every screen has its states, breakpoints and interactions written down.
• Colour pairs and type sizes pass the stated contrast checks.
• The handoff names components, tokens and open questions.
• 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 Tim Berners-Lee and Kent Beck would. This is a way of reviewing the work. It does not mean they wrote or endorse it.

Capabilities

• Check the fit. It asks if your project is big enough to need this structure, and plans lighter if not.
• Find the tangles. It looks for hard links between scripts, singletons, Find calls, magic strings and scripts that do more than one job.
• Map the data. It lists who reads and who writes each shared value, such as health or score.
• Design the assets. It plans variable, event and runtime-set ScriptableObjects, and where they sit in your Assets folder.
• Split the scripts. It breaks big scripts into one-job components and checks each prefab works alone.
• Order the work. It puts the changes in small steps, each safe to test before the next.

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 unity-architect 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/unity-architect/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

• Your Unity version and the platforms you build for
• The systems you want to tidy, such as health, inventory or UI
• Your scripts, or a list of the big ones and what they do (optional)
• Who edits game data, such as designers with no code skills (optional)
• The problems you have, such as scene bugs or slow frames (optional)

Helpful context (optional)

• The list of your scripts with line counts.
• A short note on your team, such as who is a designer and who is a programmer.

Tools and access

• Claude, ChatGPT or Gemini: Any of them can read a set of scripts and map who talks to whom. Upload files if your AI allows it.

Functions and deliverables

• Unity software architect: Plan a Unity project structure with ScriptableObjects so systems stay separate, designers can edit data, and oversized scripts get split up.
  • A list of tangled spots in what you shared, such as singletons and oversized scripts
  • A data map that shows what each script reads and writes
  • A list of ScriptableObject assets to create, each with its job
  • A plan for splitting big scripts into one-job components
  • A cleanup order in small steps you can test one by one
  Source: Michael Sitarzewski and Agency Agents contributors.
• HR project plan builder: Plan an HR project, such as a new HR system or policy rollout, with a charter, milestone timeline, risk list and weekly status report.
  • A one-page project charter
  • A milestone timeline with owners
  • A who-does-what chart and a communication plan
  • A risk list with a fix and an owner for each
  • A rule for handling scope changes
  • Templates for the weekly status report and lessons learned
  Source: Tuan Duc Tran.
• Data system design reviewer: Describe your app’s data and access patterns. Get storage choices, trade-offs and a score out of 10.
  • Recommended storage and replication
  • Splitting and consistency choices
  • Score out of 10 with failed checks
  • Fix list to improve
  Source: Wondel.ai.
• Software package upgrade planner: Get a staged plan to move one package to a new major version, with what will break, a test for each step and a way back if it fails.
  • A list of likely breaking changes, each with its source
  • A table of which other packages must change first
  • Numbered upgrade stages, one major step each
  • The tests to pass before each next stage
  • A return point for every stage
  Source: sickn33.
• Brand profile builder: Share your website. Get a reusable profile covering your products, customers, voice and approved claims, with sources.
  • A folder of eight plain files, from a start file for your AI to a claims list and a change log
  • A tag on every fact, and every claim marked approved, pending or banned
  • A two-sentence diagnosis of your biggest gap, and a list of what's missing and who can answer it
  • A short slice for your next step, if you name one
• Tim Berners-Lee: Review a system or shared knowledge plan using Tim Berners-Lee’s recorded approach. Link existing information, choose simple formats and check control points.
  • Your problem worked on the way Tim Berners-Lee would: their questions, their method, their push-back
  • The answer or the work, in Tim Berners-Lee's voice, using their ideas by name
  • Anything that goes beyond their public record, marked
  • One suggested next step
• Kent Beck: Plan a software change using Kent Beck’s recorded approach. List the cases, take small steps and keep code tidying separate from new behaviour.
  • Your problem worked on the way Kent Beck would: their questions, their method, their push-back
  • The answer or the work, in Kent Beck'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

• One script runs half your game and every change risks breaking something else.
• Your designers must ask a programmer to change a number, because values sit inside scripts.
• Your prefabs only work in one scene, or break when you load another scene.
• You are starting a bigger Unity project and want the structure settled before you write systems.

Limits to check before starting

• You are building multiplayer or networking. Use the Unity Multiplayer Engineer agent.
• You want a custom editor window or import rule. Use the Unity editor tool developer.
• You want a shader. Use the Unity Shader Graph artist.
• You are making a small jam game or a throwaway test. This structure may cost more time than it saves.

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 and add it to your AI as a skill. If you cannot, paste SKILL.md and then references/source-agent.md into a new chat.
• Say your Unity version and which systems you want to tidy. Paste the scripts that cause pain. Say MISSING for anything you do not know.
• Say "Plan this. Tell me if this is too much for my project." Your AI asks once for anything missing.
• Read the fit check first. If it says the project is small, take the smaller plan.
• Do the cleanup in the order given, one step at a time. Run your game after each step.
• Paste any new errors back and ask for the next step.

Read it as data

Read the complete role setup as JSON. Connect your AI to the AI Blocks MCP library and read aiblocks://roles/unity-architect 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.