Skip to main content

Using the Dev Kit

The AI Dev Kit works through conversation with your AI coding agent. Describe the outcome you want, identify any constraints, and let the agent inspect the actual project before it recommends or changes an implementation.

A Typical Workflow​

For most requests, a skill-enabled coding agent will:

  1. identify whether the task concerns architecture, an existing project, a new template, a guide, or a runtime problem;
  2. load only the io.Intelligence references relevant to that task;
  3. inspect project files, installed packages, configuration, and available commands using its normal development tools;
  4. consult the official documentation for exact public APIs and current product behavior;
  5. explain or implement a solution that fits the project instead of assuming a fixed application structure;
  6. select verification appropriate to the change, the available environment, and the evidence it can obtain.

The coding agent owns project inspection and verification because it has the best situational knowledge. The skill provides specialized product knowledge and evidence boundaries; it doesn't impose a universal command or test checklist.

Learn and Plan​

Use the kit to shorten the path from a product goal to a concrete io.Intelligence topology. It can explain how MCP, Working Context, AI Web, io.Assist, AI Mastra Bridge, and the Agent Protocol fit together, then relate that model to your project.

Example prompts:

Explain the io.Intelligence package topology for an Angular application that needs a packaged assistant, live Working Context, and MCP Apps.
Inspect this repository and propose the smallest io.Intelligence integration that exposes our existing application actions as MCP tools. Do not edit anything yet.

Build or Extend an Assistant​

The kit supports three main frontend paths:

  • Packaged io.Assist for a ready-made React or Angular assistant experience consumed through a published package.
  • Editable io.Assist for a React or Angular application that starts from the official assistant source and becomes a customer-owned fork.
  • Custom AI Web for a framework-free template or an existing application that needs direct control over its assistant UI and behavior.

For new applications, ask the agent to select one official template. For an existing application, ask it to preserve the project's framework, build system, dependency conventions, and configuration patterns.

Example prompts:

Materialize the official editable Angular io.Assist template in ./support-assistant. Explain the ownership tradeoff before changing the generated source.
Add a custom assistant experience to this existing web application with AI Web. Inspect the current architecture and show me the proposed integration points first.

Add io.Intelligence Capabilities​

The skill can guide implementation and troubleshooting across the framework, including:

  • MCP tools, resources, prompts, servers, clients, and transports;
  • Working Context collection and integration;
  • MCP Apps and workspace widgets;
  • AI Web threads, messages, streaming, prompts, and resources;
  • sampling and elicitation flows;
  • packaged and editable io.Assist applications;
  • AI Mastra Bridge and Agent Protocol-compatible custom bridge adapters.

For exact types, options, and signatures, the agent should consult the relevant API Reference rather than reproduce an API from skill memory.

Connect an Existing Agentic Backend​

An agentic backend isn't required to use the AI Dev Kit. When you are ready to run an assistant application, however, the frontend needs a backend that implements the io.Intelligence Agent Protocol.

Building the underlying LLM agent or its business logic is outside the kit's scope. The kit can help with the io.Intelligence-facing integration:

  • configure AI Mastra Bridge when the backend uses Mastra;
  • understand the Agent Protocol contract;
  • design or implement a custom bridge adapter around an existing backend;
  • diagnose route, streaming, tool-call, thread, or message-conversion problems at that boundary.

Example prompt:

Inspect this backend and map its current streaming and thread APIs to the io.Intelligence Agent Protocol. Tell me whether AI Mastra Bridge applies; otherwise plan a custom adapter.

Follow the io.Assist Anywhere Guide​

Ask the agent to accompany you through the io.Assist Anywhere guide. It can:

  • explain the goal and expected result of a chapter;
  • help prepare the starter applications and prerequisites;
  • relate guide steps to the files in your local project;
  • answer questions as you progress;
  • compare actual evidence with the guide when you become stuck;
  • help extend the completed solution.

Tell the agent which chapter you are on, what you have completed, and what result or error you observe. It should preserve the guide's learning sequence unless you explicitly ask for a different path.

Diagnose Problems​

The kit uses an evidence-led diagnostic workflow. The agent should inspect the relevant code, configuration, package topology, logs, network behavior, or runtime environment before settling on a cause.

Useful prompts include:

Our MCP tool is registered but doesn't appear in io.Assist. Inspect the project and runtime evidence, identify the failing boundary, and explain the likely cause before proposing changes.
This assistant streams the first response but continuation after a frontend tool result fails. Trace the Agent Protocol and bridge flow in this project.

Verification remains specific to the task. If the agent can build a project but can't launch it correctly in io.Connect Browser or io.Connect Desktop, it should state that io.Connect-integrated behavior wasn't inspected rather than treating a standalone web process as proof.

Documentation and Knowledge Boundaries​

The skill uses progressive disclosure: it begins with compact routing guidance and loads specialized references only when the request needs them. It then uses the official documentation as the definitive source for public APIs and capabilities. The documentation exposes an LLM-compatible content map for efficient discovery.

V1 assumes that the installed kit, current official documentation, and locally available io.Intelligence packages are aligned. Review Capabilities and Boundaries before relying on the kit for projects pinned to an older product version.