How to Start a Project

The primary way to build in Stellify is the development loop: connect your editor over MCP, let AI find existing code and wire it into your project, sync back or export. But the loop isn't the only way in — you can also write code yourself in the cloud editor or import a codebase — and all three produce the same structured code, so you can mix them freely within one project.

Starting a Project

Import from GitHub

Connect a repository in Project Settings → GitHub Integration, pick the repo, and import. Stellify parses controllers, models, routes, and Vue components into its structured format — after that they're editable like anything built natively, by you or by an agent.

Working from your own IDE instead? Import via MCP — the agent reads your local codebase and recreates it in Stellify, converting from other frameworks along the way if needed.

Start Fresh

Click New Project, name it, and you have an empty Laravel + Vue project. The fastest path from here is to hand the first pass to an agent — see below — and take over in the editor where it matters.

Building with an Agent

Open the AI chat in the editor (or connect your own agent via the MCP server) and describe the feature:

The agent isn't generating a text diff for you to paste in. It works with the same objects you see in the editor: it scaffolds the Model/Controller/Service/Migration stack with one tool call, wires routes, edits individual methods, and builds UI elements — and it checks the shared library first, so a feature that already exists gets referenced instead of regenerated. Changes land in your project as it works; run the code or the tests to verify before you move on.

What to hand the agent, and what each prompt actually does:

• "Create a user registration form with email and password validation" — a route, a controller method with the validation, and a Vue form component wired to post to it
• "Add a search method to UserController that filters by name or email" — one new method added to the existing file; nothing else touched
• "Build a dashboard page showing recent orders and total revenue" — the page route, the queries, and the UI elements to display them

Writing Code Yourself

Everything the agent can do, you can do by hand:

• The Code Editor — method-level PHP and JavaScript editing with autocomplete and an in-editor run panel
• The Interface Builder — click-to-select visual UI editing on a live preview

In practice the split is: agents for scaffolding and bulk work, the editor for the logic you care about getting exactly right. Both operate on the same structured code, so there's no handoff cost.

Capabilities

Your business logic runs on framework features — auth, payments, mail, storage — that Stellify manages as capabilities. Enable them in Project Settings; enabled capabilities become dependencies in your export's composer.json.

Two things worth knowing:

Agents check capabilities before building. Ask for Stripe checkout and the agent verifies the Stripe capability is enabled and configured before writing code against it. Capabilities marked Needs Config want API keys saved in Project Settings first.

Missing capabilities become requests, not hallucinations. If a feature needs framework-level support that doesn't exist yet, the agent logs a capability request instead of inventing infrastructure code. The Stellify team reviews requests, builds what's needed, and emails you when it's available. What you build directly shapes what the platform supports.

A Typical Build

One pass through the development loop, feature by feature:

1. Find — "Add user auth — check the library first"; existing units get referenced in, not regenerated
2. Scaffold the gaps — "Create a Post model with title, body, and author relationship, plus a PostController with CRUD" — one create_resources call
3. Migrate — apply the generated migration to your connected database
4. Build the page — describe the UI, or construct it in the Interface Builder; wire buttons and forms to controller methods
5. Refine — open the methods that matter and edit them directly
6. Verify — run methods with test input from the editor; run the test file
7. Ship — sync to GitHub or export as a standard Laravel project

Next Steps

• Tour of the Platform - Where everything lives
• Code Editor - Method-level editing
• Interface Builder - Visual UI construction
• The MCP Server - Connect your own agent