If you are new to Magic, the fastest way to understand its power is to use it.
Not by reading abstract feature lists. Not by watching product demos alone. But by actually installing it, opening the Expert System, and creating your first AI agent with your own hands.
That is exactly what this tutorial is about.
In this article, I will walk you through how to get started with Magic, install the Expert System, and create your first AI agent step by step. The goal is not to explain every advanced concept in the platform. The goal is to get you from zero to first success as quickly as possible.
If you prefer video, watch the walkthrough below first, then follow the written tutorial afterwards.
What this tutorial covers
By the end of this guide, you will have:
- installed Magic
- opened and used the Expert System
- created your first AI agent
- understood how to approach your first practical build inside the platform
This is a hands-on tutorial, so the focus is on doing, not theory.
Why start with Magic this way
One of the easiest mistakes when approaching a platform like Magic is trying to understand everything before doing anything.
That is usually the wrong order.
Magic becomes much easier to understand once you see the system in motion.
When you ask it what it can do, when you let it suggest a plan, when you create a database, when you design a CRUD API, and when you watch it turn plain English into working software, the platform starts making sense much faster.
That is also why the walkthrough behind this article is useful. It shows the actual creation process, not just the polished result.
If you want to inspect the original creation session, you can find it here:
Step 1. Install and launch Magic
Your first job is simply to get Magic up and running.
At this stage, do not worry about building something complicated. Just get the environment running so you can interact with it.
If you want a step-by-step walkthrough for the open source version, watch this video:
You can download or clone Magic from GitHub here:
Once Magic is installed and launched, open the interface and make sure you can talk to the system.
The point of this first step is not complexity. It is momentum.
You want to get to the place where you can type a request in plain English and see the system respond.
If you prefer, watch the installation video first, clone the repository, get Magic running locally, and then continue with the rest of this tutorial once the interface is responding.
Step 2. Open the Expert System
Once Magic is running, the next step is to install and open the Expert System.
This is where things start becoming interesting.
The Expert System is the environment where you interact with Magic in a more practical and productive way. Instead of manually wiring together everything yourself, you can begin working with the system conversationally and let it help you create real software artifacts.
This is also the point where many people first realize that Magic is not just another chatbot.
It is a software creation environment.
That distinction matters.
To install the Expert System from the main Magic dashboard, open Manage, then go to Plugins, and install the Expert System from there.
Once the plugin has been installed, open the Expert System and verify that you can interact with it.
If Magic is your runtime environment, the Expert System is the place where that runtime starts becoming a practical software creation assistant.
Step 3. Ask Magic what it can do
A great first prompt is a simple one.
Ask it what it can do.
That gives you a feel for the platform's scope and also helps you understand the kinds of tasks it can help you automate.
In the creation session behind this article, that first step produced a broad set of capabilities, including:
- full stack app creation
- CRUD APIs
- websites and landing pages
- widgets
- AI agents and chatbots
- databases and SQL
- file and module management
- authentication and RBAC
- Git and GitHub workflows
- browser automation
- web scraping
This is a useful moment because it frames the rest of your work.
You are not just talking to a general AI assistant. You are working with a system that can create, modify, and orchestrate software.
Step 4. Start with a very small project
For your first project, do not try to build an ERP system, a multi-tenant SaaS, or an autonomous sales platform.
Start with something tiny.
In the walkthrough, the example project was a simple TODO app.
That is a good choice because it is small enough to understand, but still touches the things you actually care about:
- data
- APIs
- structure
- planning
- user-facing functionality
A good first prompt is something like this:
I want to create a small database to manage my tasks, a TODO app. Suggest a plan.
That is a strong beginner prompt because it gives Magic a clear objective without overspecifying the implementation.
Step 5. Let Magic suggest the plan
This is one of the most important habits to develop.
Before asking the system to generate code, ask it to suggest the build plan.
In the original session, Magic responded with a practical sequence:
- define the first version
- design the database
- create the backend API
- create the frontend
- keep version 1 simple
- add improvements later
This is exactly the right way to work.
Instead of jumping directly into implementation, you let the system decompose the task first.
That gives you a cleaner result and helps you stay in control.
Step 6. Create the database
Once the plan looks sensible, move to a concrete step.
In the walkthrough, the next step was to create a SQLite database for the TODO app.
The user simply asked for a database named my_todo.
That is a good example of how to work with Magic in practice.
Do not overcomplicate your prompts. Give the system a clear next action. Then evaluate the result. Then continue.
This is much more effective than trying to compress an entire application into one giant prompt.
Step 7. Think in resources and CRUD
After creating the database, the natural next step is to think about the shape of the API.
In the example session, the CRUD API centered around a tasks resource with endpoints for:
- listing tasks
- getting a single task
- creating a task
- updating a task
- partially updating a task
- deleting a task
This is another important lesson for beginners.
Magic works especially well when you give it clean, well-bounded tasks.
A resource-oriented mental model makes this much easier.
Instead of thinking vaguely about “building an app,” think in terms of:
- what data exists
- what operations should be possible
- what a user should be able to do
That gives the AI a much stronger foundation.
Step 8. Create your first AI agent
Once you have gone through a small practical build, you are in a much better place to create your first AI agent.
At this point, you have already seen the most important idea behind Magic.
Natural language is not just a chat interface. It is a way to define software intent.
When you create your first AI agent, think in terms of a clear purpose.
For example:
- a support assistant trained on your documentation
- an internal assistant that helps with database records
- a workflow agent that performs backend tasks
- a chatbot that can use tools to solve a narrow business problem
The key is to start small and specific.
Your first successful AI agent should do one thing well. That is much more valuable than a broad but unreliable assistant.
Step 9. Keep the first win small
This may be the most important advice in the whole article.
Your first win should be boring.
That is not an insult. That is a strategy.
A boring first success teaches you how the platform behaves, how to sequence prompts, how to review results, and how to refine your requests.
Once that pattern clicks, you can move to bigger things:
- authenticated apps
- richer frontends
- AI chatbots with RAG
- visual widgets
- generated APIs
- advanced automation
- production workflows
But the shortest path to those bigger successes is a very small first project.
A practical way to follow this tutorial
If you want to reproduce the flow shown in the video, do it in this order:
- Install and launch Magic
- Install the Expert System from Manage and then Plugins in the main Magic dashboard
- Open the Expert System and verify you can interact with it
- Ask Magic what it can do
- Choose a tiny starter project
- Ask for a plan before asking for code
- Create one concrete artifact, such as a database
- Expand gradually into API design and agent creation
That sequence gives you the best learning curve.
Common beginner mistake
The biggest beginner mistake is trying to use Magic like a one-shot app generator.
It can do impressive things, but the best results usually come from collaboration.
You give intent. The system suggests a structure. You confirm direction. It executes the next step. You refine.
That loop is where the real power is.
Magic is at its best when used as a software creation partner, not as a slot machine for random prompts.
Where to go next
Once you have completed your first simple tutorial, the next natural steps are:
- build a full CRUD API
- create a small frontend
- add authentication
- create an AI chatbot trained on your own data
- add visual widgets to an AI agent
- connect the system to an existing database or API
At that point, you are no longer just trying Magic. You are building with it.
And that is where things become fun.
Final thoughts
The best way to get started with Magic is not to aim for perfection.
It is to aim for your first working result.
Install it. Open the Expert System. Create something small. Let the system plan with you. Then build on that momentum.
If you do that, you will understand the platform much faster than if you try to learn it purely from descriptions.
The video embedded above shows the full walkthrough. The original creation session shows the real interaction behind the result. Together, they are probably the fastest path from curiosity to competence.