Build Apps with a coding agent

When client feedback arrives in several threads, somebody has to find the latest revision, work out who is reviewing it and chase the missing decision. A proposed Creative Review App could keep those details together, so your team spends less time reconstructing status before doing the next piece of work.

You can ask a coding agent to build this kind of App from the open-source repository today. It can reuse customer records, workspace access and existing business services, which reduces the setup and repeated implementation needed for each custom workflow. You supply the business rules and review a working result; the agent writes the source, registers the extension and runs the checks.

Decide what the App should do

For a client review queue, the owner specifies who submits work, who reviews it, which revision a decision applies to and what happens after changes are requested. A useful result shows the current revision, reviewer and outstanding decision together, with the customer history available from the same workspace.

The agent chooses the implementation from those rules. Depending on the workflow, it may need a dedicated screen, new records, a provider connection or an AI tool. Shared customer identity and access checks give it a starting point, while the parts unique to your process still need implementation and verification.

Give the agent a complete brief

Give this brief to Codex or Claude Code in the Accelerate repository to commission the proposed Creative Review extension. For fictional test records, an agency could review work for Northline Roofing & Exteriors, one of the demo businesses, without using real customer data.

Read docs/NORTHSTAR.md and then AGENTS.md. If this is an assigned Feature Board task, follow its live execution packet and approved source. Build a Creative Review App for an agency so the team can find the latest client revision and outstanding decision in one place. Reuse canonical customers, memberships, activity and approval services. Add a review record for the brief, revision history, reviewer and lifecycle. Provide a review queue and a revision comparison screen. Keep preparation tasks linked to the review, and bind each decision to the revision reviewed. Use the same business operations for the interface and governed AI tools. Keep the App usable without a model call. Register its module and any required plugin or tools. Demonstrate accepted, changes-requested, stale-version, disabled-module and cross-workspace behavior with fictional records. Deliver the bundled operator README and public guide with manifest registration and a current generated index. Update the operator guide, changelog and product descriptions to match what works. Run the required checks and show the desktop and mobile result, exact tested commit and remaining limitations. Hand off publication separately.

Add your actual review rules, an example submission, any deadlines and the systems it needs to reach. Say whether completion should save an internal decision, create the next task or send something outside the workspace, because each result needs its own verification.

Follow your first working adaptation for setup and the first handoff. For shared work, the live Feature Board owns the approved scope, dependencies and verification evidence, so another agent can continue from the recorded assignment and source.

Review what work it saves

Ask the agent to walk through one complete example, from submission to a recorded decision and the next person's view. Check whether somebody can find the current revision and take the next step without copying status between tools. If the team still has to maintain a parallel spreadsheet, explain the missing step so the agent can address it in the same workflow.

The handoff should include a working preview, setup instructions, the source changes and named check results. Review the business behavior yourself, and have the technical review confirm permissions, saved records and recovery before release.

Planned: create and update Apps inside Command Center

The intended experience is:

1. Describe an App or a change to an existing App, with relevant business context.
2. Generate a draft in an isolated development workspace.
3. Preview the working interface with fictional or explicitly scoped data on desktop and mobile.
4. Inspect its source, dependency changes, requested capabilities and data migrations.
5. Run checks for business behavior, permissions, replay, failures and the user interface.
6. Review and publish the exact verified App version.
7. Reopen that version for further changes, compare versions and roll back compatible code when needed.

The current source extension path and bounded plugin runtime provide parts of that foundation. The complete in-app authoring flow remains planned.

What an App can become

An App can add custom records, work types, connections to other systems and a dedicated interface. The agent can contribute its records to supported shared views or implement a workspace designed around the business process. App design, custom work and custom UI explain these implementation choices.

A planned development terminal would need an isolated execution environment, scoped access to connections and secrets, resource limits and an inspectable result.

What to check

Creative Review is a proposed extension, not a bundled App. Use an external coding agent and the repository's source-development workflow today; treat the general-purpose in-app App builder and development terminal as planned.

Bind source, dependencies, requested access, any database changes and check results to the exact version reviewed. Preserve customer identities and execution history across updates, and verify recovery using the documented release workflow.

Check external-action receipts before telling someone that a message or business operation completed. Plan recovery for database changes and completed external actions separately from restoring an earlier code version.