Running your project
AI Coding
What this page is for: have a coding agent change the code of one project for you. You write what you want in a chat inside the panel; a coding program runs on your server, as that project's own account, reads the code, changes it and checks its work. You see every file it reads and every change it makes, and it works on a staging site first, so the live website is not touched until you move the work there.
AI Coding runs Claude Code (Anthropic's coding program) — or Codex (OpenAI's) when the provider you use is a ChatGPT plan. The panel installs the program, keeps it current and starts it; you never open a terminal for it.
Open AI Coding in the panel's menu for the whole server, or AI Coding inside a project or a website to work on that one.
You need
- SixPanel Pro. Without it the page shows an upgrade card above what it does. See Your AllsWeb account and SixPanel Pro.
- The owner's login. A temporary login and the read-only demo cannot use AI Coding.
- A server with enough memory — see What the server needs.
- An AI provider that can serve coding — see Providers and plans.
The rule that does not move: the program works as the project's own account, never as root, inside that one project. It cannot use sudo, and anything it asks the panel to do — a deploy, a look at the logs — goes through the panel's own checks and approvals, as for any other AI agent. With Claude Code the panel also refuses the commands that destroy data; with a ChatGPT plan, Codex's sandbox is the limit — see With a ChatGPT plan: Codex.
Where it is
- AI Coding (panel menu) — for the whole server: what the server needs, the coding programs and their versions, the provider in use, every project with its number of sessions, and the last sessions. Open beside a project takes you to its page. Once nothing of the set-up waits for you, the projects and the last sessions stand at the top and the set-up under them; while something does — no provider yet, a program to install, a report to send — the set-up comes first.
- AI Coding inside a 6amMart project, and inside a website of the kind static, Node.js, PHP or WordPress — the chat itself: your sessions on the left, the conversation in the middle, its settings (where it runs, and how) on the right. The two buttons at the corners of the conversation's head fold the sessions and the settings away, and the page remembers that. On a phone or a narrow window the three are tabs — Sessions, Conversation, Settings — and the conversation fills the screen: the message box stays at the bottom, and only the conversation scrolls (a long change wraps inside its own box). Once a project has sessions, what AI Coding is folds into one line at the top, About AI Coding.
A Create with AI website has no AI Coding page: its Build with AI page is the same thing, with a live preview and Publish. See Create with AI.
What the server needs
The server's AI Coding page lists each of these with what your server has and what is needed:
| What it should have | It is refused below | |
|---|---|---|
| Memory | 8 GB | 2 GB |
Free disk on /opt | 20 GB | 1 GB |
| CPU cores | 4 | — |
| Processor type | amd64 or arm64 | |
| Linux kernel | 6.5 or newer |
When a row says Not enough, the page says Upgrade the server first — AI Coding needs at least 2 GB of memory and 1 GB of free disk, and 8 GB of memory, 20 GB of free disk and 4 CPU cores for smooth work, and nothing can be installed or started until the server has it. When only the Linux kernel or the Processor type row says Not enough (a container on an old host kernel, for example), memory, disk and cores are fine and adding them changes nothing: the page then says AI Coding cannot run on this server's system — on the card of each coding program and under a project's message box too, where a short server reads too small — and the row names what it needs — a newer kernel, or another host. A row that says Low is a warning: the server has less of that than it should have for AI Coding — it works, and long work may be slow. Free disk is such a row too: a server of the right size whose disk has filled up reads Low on that row only, and freeing space puts it right. A server sold as 8 GB reports a little under 8 GB of memory; that still counts as 8 GB.
How many sessions can work at the same moment depends on the memory: one on a small server, up to four on a large one, and never two in the same project. The page says how many are working now.
The coding programs
The panel installs the program the first time it is needed — Install Claude Code on the page, one job, a few minutes — into a folder of its own that no project can change. Signing in with a ChatGPT plan installs Codex the same way. A program is run exactly as its publisher ships it: the panel downloads it, checks it against the publisher's own checksum, starts it once as an unprivileged user, and tries it (see below) — only then is it put in use, and the version it replaced is kept.
Codex runs a session's commands inside a sandbox, and that sandbox needs the server's own bubblewrap package. The install job installs it from your release's own archive when the server has none. Where it cannot, the job stops there and says the one command to run on the server — apt-get install -y bubblewrap — and you press Install again after it.
The package alone is not always enough: the server must also let an ordinary user start a sandbox with it. The install job tries that once, before it tries Codex. Where bubblewrap cannot start — user namespaces switched off on the server, or a container guest that does not allow them — the job stops there with what bubblewrap answered and the one command to check it with. Nothing is installed and no report is sent: the cause is the server, not the version of Codex, and SixPanel does not change that setting for you.
Each program has a card on the server's AI Coding page:
- Version in use and the newest on this channel.
- Updates — one folded line that says how they are set (for example Stable · updates by itself). Open it for:
- Channel — Stable is the tested line; Latest gets every new version first.
- Update by itself (on by default) — once a day the panel looks for a newer version and installs it while no session is working.
- Check now — the same, at once.
While something AI Coding needs is still missing, the top of the server's page says Get AI Coding ready as four steps, in the order they are done — the server, the AI provider, the coding program, then a project — each marked done or not, with the one press for the step you are at (Open AI → Providers, Install …). What is short of a server is said once, in its own card below.
Channel and Update by itself are one setting for both programs: change either on one card and the other card shows the same. Codex has a single line of releases, so the channel changes nothing for it.
A newer version is tried before it is used. The panel runs it through a scripted session on your server — text, a change that needs your permission, a question, Stop, continuing a session — without using your provider or any tokens. It also checks that the panel can hand the program skills, and that nothing a website could have written — an instruction file or a skill in the project's folder or in its account's home — ever reaches it. Only a version that passes every check replaces the one in use. When one does not pass, AI Coding keeps working on the version it has, the card says held back with the checks that failed, and the report goes to AllsWeb so that a SixPanel update can follow (Reported to AllsWeb, with the time). With automatic problem reports turned off, the card offers Send this report instead; it carries the program's version and the failed checks, never a project, a conversation or a file. See Problem reports.
When the version in use works differently. A program can change in a way its trial does not show. Most such changes are additions — a new detail in a message, a kind of line this SixPanel has never seen, an effort level the program gained — and they change nothing for you: what is unknown is skipped, your sessions work as before, and the page says nothing. AllsWeb is still told, once for each version, so that a SixPanel update can follow. The program's card speaks only when a change can stop something working: the program dropped an option or an effort level a turn uses, it refuses the command a turn is started with, it asks the panel a question the panel does not know, or a turn ends in a way the panel cannot read. Then it says … works differently from what this SixPanel was written for, with What is different listing the names, and — with automatic problem reports turned off — offers Send this report. A report carries names only — an option, an event type — never what a project or a conversation holds.
Providers and plans
AI Coding uses an AI provider you added on AI → Providers. The page shows which one, its model, and the program it works with; Change opens AI → Providers. A new session can also pick another provider of your list.
There are two kinds, and they differ in one thing you should know:
- An API key (Anthropic, or another provider or endpoint that can serve coding). The key never leaves the panel. The program talks to a door inside the panel, which adds the key and passes the request on; the project's account never sees it.
- A plan — Claude (Pro, Max, Team) or ChatGPT (Codex). You sign in once, on AI → Providers, not per project. Anthropic and OpenAI allow a plan to be used only inside their own coding program, so a plan's sign-in is handed to that program, which works as the project's own account: while a session is working, the sign-in is within that program's reach. The Claude sign-in can only make model requests, and you can end it at claude.ai at any time. A plan serves AI Coding and Create with AI's coding — not Tia and not monitoring.
When the provider is a plan that is not signed in (or its sign-in has ended), the AI Coding page says so and sends you to AI → Providers; there is no sign-in on the AI Coding page itself. A Claude plan's sign-in lasts one year: from two weeks before its end the provider line here says Its sign-in ends in … days, as its row on AI → Providers and the bell at the top of every page do. See AI providers — its What is the difference? puts a plan beside an API key in three lines.
Start a session
- Open AI Coding in the project or website.
- On the right (on a phone: Settings), choose where it runs — see the next section. Staging site is chosen for you.
- If you like, open How it works under it and choose the mode, the model and the effort (more effort thinks longer and uses more tokens — see Effort, and Ultracode). The line beside Attach under the message box says what is chosen; pressing it opens them.
- Write what you want changed and press Start — or Enter.
The program reads the code first, does the work, and ends by saying what it changed and how it checked it. Write again to continue: a session remembers its conversation, also after the panel was restarted. New session starts a fresh one (on a phone it is also at the top of the conversation); a session can be renamed or deleted from the list — deleting removes the conversation from the page, not what it changed in the code.
Writing a message
- Enter sends; Shift+Enter starts a new line. (Ctrl+Enter, and ⌘+Enter on a Mac, send as well.) On a phone or a tablet without a keyboard, Enter is a new line and the button sends.
- The box grows as you write, up to about two fifths of the window.
- What you are writing is kept. Leave the page or reload it, and it is in the box again — in this browser tab, until you send it.
- You can write the next message while it works. Press Send (or Enter): the message waits in the box, the line under it says so, and it is sent when the turn has finished. After a turn that stopped with an error, or that you stopped, nothing is sent — it stays in the box for you to decide. Empty the box to take it back.
- Esc in the message box stops a turn, like Stop.
- Photos and files go with a message. Press Attach, paste a picture into the box, or drop files on it. A photo (PNG, JPEG, GIF or WebP) may be up to 10 MB, any other file up to 25 MB, and ten go with one message. Each is sent as soon as you add it and shown under the box; × takes one off again. The coding program is handed each photo as a picture and every file by where it is kept — outside your project's code, so nothing you attach ends up in git. They stay with the session and go when you delete it. Something attached and not sent yet is still there after a reload.
- Type
/at the start of the box to see the coding program's own commands (for Claude Code:/compact,/context,/costand more). The list is the program's, read from its last turn, so a session shows it after its first message. A message that is only such a command is carried out by the program itself. - A session that is ready says how its last turn ended in the list: finished, or stopped when you or a restart of the panel stopped it.
Before the first message: git
A session works without git. With it, every step the program takes is a commit you can look at and take back — so the page asks, before your first message:
- This project has no git repository. Connect a repository opens the project's Deploys page, where a repository and its deploy key are set up; that is also what makes Move to production possible. A PHP website has a second choice, Set up git here: the website's folder becomes a repository of its own, with a first commit of the code as it is now. Nothing is sent anywhere, and the files that hold passwords (
.env,wp-config.php) are kept out of it. It has no remote: the program commits there as it goes, and nothing is pushed. A WordPress website is not offered it: WordPress stops updating itself in a folder that holds a repository. - The repository does not keep enough out of git. When dependencies, caches, logs or uploads are not ignored, the page lists the missing lines, and Add them to .gitignore adds them at the end of the file. Nothing is ever removed from it, and
.envis left as your project has it — in a 6amMart project it stays in git.
Not now closes the card. Nothing is set up unless you press for it, and a project that stays without git works exactly as before.
What you see
- Where you are, under the session's name: Ask for a change → Watch it work → Review what changed → Keep it, or undo it, with the step the session is at marked. (On a phone only that step has its word.)
- Review what changed, at the end of a turn that changed files: the files it changed — press one to open its change in the conversation — where to try it (Open the staging site), how to keep it (on a staging site that follows a branch: Move the work to production in Settings), and Undo it. Undo it writes a request in the message box for the agent to put those files back as they were before the turn; nothing is sent until you read it and press Send.
- Where it runs, always: Staging or Production beside the session's name — before the first message too.
- Its words, as they are written. A block of code in them has Copy.
- A row for everything it does — the file it read, what it searched for, the command it ran, the file it changed. Press a row to open it: the whole command, what came back, and for a change its diff, with the lines added and removed. A row stays shut until you open it, however much came back.
- A permission card when it needs your yes: what it wants to run or change — for a change to a file, the change itself — and Allow, Always allow (for the rest of this session, for that kind of command) or Deny — with a line for what it should do instead. On a phone the page moves to the card when it arrives.
- A question card when it needs a decision from you.
- Stop while it works. What was changed up to that moment stays.
- What a turn cost, in tokens, beside Done; the session's total is at the top.
- If you scroll up to read, the page stays where you are; the ↓ button brings you back to the newest words.
- Something new. When a newer version of the coding program has a mode, an effort level, a tool or a kind of message this SixPanel has no words for yet, it is shown by its own name — nothing is left out.
- Waiting for your approval when it asked the panel for something the panel asks you about (a deploy, for example) — the same card as in the bell at the top.
Modes
With Claude Code:
| Mode | What it does |
|---|---|
| Ask before changes | Every file change and every command waits for your Allow. The mode production starts in. |
| Edit files, ask before commands | Files are edited without asking; a command still waits. The mode a staging site starts in. |
| Plan only | It reads the code and proposes a plan. Nothing is changed. |
| Bypass permissions | Nothing is asked. What the panel never allows is still refused. On production the agreement you ticked to work there covers it — nothing more is asked. |
Codex has no step that waits for your Allow, so it is not offered the first two. Its modes are Plan only, Edit files and run commands in the project (inside the project's folder, without asking), and Bypass the sandbox. The page always shows the modes of the program your provider works with.
Rules for this project (under How it works, on the right) holds what applies to every session of the project: commands to always allow, commands to never allow, and standing instructions such as "write comments in English". What the panel never allows stays refused whatever is written there.
Effort, and Ultracode
Effort is how long the program thinks before it acts: Low, Medium, High, Extra high, Max. More effort is more thorough, slower, and uses more tokens.
With Claude Code there is a sixth choice, Ultracode: several agents work on your request at once and check each other's work. It is the most thorough way to work — and by far the most tokens, many times what the same message costs otherwise. Choose it for a large or risky change, not for a small fix.
- You write your message as always, and the conversation shows it exactly as you typed it.
- A session keeps the effort its last message used. Set it back when the large change is done.
- Whether several agents really run also depends on your provider and model. Where they cannot, the turn runs at the highest effort — nothing fails.
- It is Claude Code's own: it is not offered when the provider is a ChatGPT plan (Codex).
How a turn runs
A turn is one message of yours and the work the program does for it.
- As the project's own account, in the project's code folder — the same account the panel's Terminal gives you for that project. It cannot use
sudo, it cannot read another project, and the panel's own files are out of its reach. - One turn per project, and a few at once on the server (one on a small server, up to four on a large one). Turns on a ChatGPT plan run one at a time on the whole server. A turn that cannot start yet is refused with the reason, and nothing is queued: send the message again when the other has finished. One message does wait: the first of a session whose staging site was still being made or set up. The session says so, and it is sent when the turn in its way has ended.
- Stop asks the program to stop, and ends it if it does not. What it changed so far stays.
- A panel update or restart ends a running turn; the session says so, and your next message continues the same conversation.
- The conversation is kept by the panel, not in the project: the newest 2,000 events of each session. Deleting a project or a staging site deletes the sessions opened on its own AI Coding page. A session opened on the project that worked on a staging site stays in the project's list after that staging site is deleted, and says so when you write in it. Moving a project to another server ends its running turn.
What it is told before your first word
Before every turn the panel hands the program a short guide to THIS project, written from the project's own record and files at that moment:
- What it runs — its kind and its framework with the version your own files name (Laravel from
composer.lock, WordPress from its version file, Next.js frompackage.json), the PHP version of its own pool, its Node.js version and package manager, every database the website has — MariaDB, PostgreSQL, MongoDB or SQL Server, each with its version and the names of the variables your app reads it by — the website's own Redis and Memcached and the Supabase it is connected to, nginx and the document root, and how it is started and restarted. A PostgreSQL database whosesixpanel.jsongives it an app role is named with the variable the running app uses, and the guide says the owner's address reaches only the build, the hooks and the deploy commands, so migrations run there. It is told to write code for exactly these versions, in the language each database speaks: nothing newer, no other database, no.htaccess(nginx does not read it) — except on a PHP website you switched to Apache behind nginx (PHP → Read .htaccess files (Apache)), where the guide says that.htaccessis read. The guide says where a password is kept, never the password. - Which 6amMart this is — in a 6amMart project the guide says whether the tree is the untouched CodeCanyon code or AllsWeb's changed copy, read from the tree itself (the changed copy has a
config/runtime.phpthe untouched code does not), with the version the tree declares. It also says what the panel measured at the last deploy: whether the code reads a live setting with a bareenv()outsideconfig/(named, so the program adds no other and caches nothing), or that it does not. Before the first deploy it is told that this is not measured yet. The program never assumes a file or a fix of the other codebase is there. - Where SixPanel's manual is — this manual, for the release your server runs, is on the server: the guide tells the program to read the page about deploys,
sixpanel.json, databases or staging before it changes how the project is built or deployed, withsixpanel docs <words>(and the same search through the panel's tools) or by reading its pages as plain files on the server (the guide names the folder), never from memory or another host's documentation. - Check sixpanel.json before committing it — on a website, the program checks a
sixpanel.jsonit wrote or changed withsixpanel appfile check(or thecheck_sixpanel_jsontool) and fixes every error it names before it commits: the check plans the file against the website as the next deploy would, and deploys nothing. A 6amMart project has nosixpanel.json, and is not offered the command. - Read first, change little, check before saying done — it reads the code it is about to change, makes the smallest change that does what you asked, and runs the project's own checks when it has them (composer scripts,
npm test,lint,build,php -lon the PHP files it changed) before it tells you it is finished. - Commit as it goes — on a staging site that follows a branch it commits each working step with a real message, and the panel pushes that commit to the staging site's branch (the project's account holds no key for your repository). Before it says the work is ready, nothing is left uncommitted. If a turn does end with changes that are not in git yet, the page says so under the conversation, with Commit and push beside it.
- The project's notes — where its brief and its memory are, to read them before it starts and to write what it learns into them (Project notes).
Instruction files in the project. Your project's AGENTS.md and CLAUDE.md reach both programs as they are committed in its repository. The panel reads them from git before every turn and hands them to the program with its other instructions, in a file only the project's account can read, in the program's own folder: never on the program's command line, which other accounts on the server can see. Neither program reads these files from the project's folder itself, nor a .claude folder or anything in the project account's home folder. The website runs as that account and can write those files, so a hacked website could otherwise give the program orders. A change you have not committed yet is therefore not read: commit it, and the next turn has it. A folder that is not a git repository gives neither program an instruction file; put what every session should know in Rules for this project → Standing instructions instead. No skill in the project's folders or in the account's home is offered to either program, and Codex is told to ignore each one it finds there, even when a message names it as $name. When those folders hold more skill files than one turn can switch off (hundreds, with long names), or one whose name is not valid text, Codex is not started: the turn says which folders to clean, and nothing is switched on. The panel never changes your instruction files, and writes no instruction file into your repository.
What it asks you, and what is never allowed
In Ask before changes every edit and every command waits for your answer. Always allow keeps the program's own suggestion — for that kind of command, for this session only: it never adds a folder outside the project and never turns asking off.
With Claude Code, some things are never allowed, in any mode: sudo, and the commands that wipe a database or cache its settings by hand (migrate:fresh, db:wipe, config:cache, wp db reset and the like). Your own extra rules are under Rules for this project. Codex cannot use sudo either, but the panel's list is not applied to it: its sandbox is the limit — see With a ChatGPT plan: Codex.
The sixpanel command works inside a session — status, logs, deploy, commit, sync — for this one project, whether or not Let an agent work on the server itself is switched on (see An agent on the server, inside one project). What it does shows on the Activity page as via ai:mcp:code: and the account's name; anything that cannot be taken back (a promote, a delete, a restore) still waits for your approval — in the session, and in the bell at the top of every page.
With a ChatGPT plan: Codex
When the provider is a ChatGPT plan, the work is done by Codex — OpenAI's own coding program — because OpenAI allows a plan only inside that program. The panel installs it, keeps it current and tries every new version before using it, exactly as for Claude Code. It differs in five things:
- None of its modes asks. Plan only reads the project and proposes a plan; no file can be written (the panel's own tools still answer — see the next point). Edit files and run commands in the project edits files inside the project's folder and runs commands there without asking. Bypass the sandbox: no sandbox, and nothing is asked. A session with Codex never shows a permission card or a question card — so work on a staging site, as with every session.
- Its sandbox has no network. In Plan only and Edit files, a command Codex runs cannot write outside the project's folder and cannot open a connection — not to the internet and not to this server's own services. So
composer install,npm install,git fetchandgit pushdo not work there, and neither does thesixpanelcommand typed in a shell. The panel's own tools still work, because Codex reaches them directly: in Edit files all of them — status, logs, what changed, commit, deploy, the staging-site tools — and anything of theirs that needs your approval waits for you as always. In Plan only it is the ones that only read (status, logs, what changed): a tool that changes something — a deploy, a commit, a setting — is refused there, so Plan only changes nothing through the panel either. When a step needs the network (a package to install), Codex tells you which command it needs: run that turn in Bypass the sandbox. - No diff, and the answer comes whole. A file Codex changes is listed by name with what happened to it — added, edited or deleted — but not which lines; the staging site's what changed card shows those. Its answer appears when it is ready, not word by word.
- Rules for this project are read by Claude Code only. Codex does not apply the allow and deny lists, and the session says so when you have any. The same goes for the panel's list of commands that are always refused: in Plan only and Edit files Codex's sandbox is the limit, and in Bypass the sandbox there is none — choose it on production only when you mean it.
- One Codex turn at a time on the whole server, across all projects: OpenAI permits one user of a plan's sign-in at a time. A second one is refused until the first has finished — send the message again then. Codex reports what a conversation has used so far; the session shows each turn's own share of it.
Start a new app
Build a whole product from a description, the way an experienced team starts one: it understands first, asks you once, then builds without stopping, and reports back. Open AI → AI Coding and press Start a new app — or, on Projects, press Create a new project and pick New app with AI Coding, which opens the same screen.
- Describe it. Give it a name and write, in your own words, what you are building and who uses it. Under the box, What this server gives your app is filled in for you: SixPanel on this server, a new PostgreSQL database with its own app role, the server's Node.js, Git on this server, and where email and storage are set (in the app's own admin, never as environment variables). If PostgreSQL is not installed the card says so and Fix it opens Software. Press Plan it. Nothing goes live.
- Questions. The panel makes a Node.js website that is not live (no domain yet), its database, a code folder that is a git repository of its own with a generated
sixpanel.json, and the project notes with your brief. The coding agent reads the brief and writes one question card:
- the filled table (brand, roles, login, payments, languages, scale…), with each value it guessed marked guessed;
- What I understood: the roles, the main flows and the pages;
- features your brief did not mention, each ticked or not as it recommends;
- only the questions it could not answer, each already holding the recommended answer;
- tools or logins still missing, with the command for each.
Change anything you like, then press OK, build it. Pressing it without changing anything takes every recommendation. Your answers are added to docs/brief.md under your brief, which stays as you wrote it.
- Building. The agent writes
docs/checklist.mdfirst and ticks each line, with its proof, as it is done. The page shows it as a checklist with a progress bar, updated on its own. Open the conversation shows every step, as in any session. It does not stop to ask again: a small choice it makes itself is written indecisions.md. - Ready. The agent writes its final report (
docs/report.md): what was built, the versions, the test results, the choices it made for you, and what you must do. That means each key or account only you can give, with its steps. - Go live. Only you press it. First type APP_SECRET on the website's Environment page: a long random value of your own, at least 32 characters, which seals the app's data. Then type the domain visitors will use and press Go live. The panel adds the domain, gets HTTPS and builds the app on it. Afterwards Deploy the newest code puts later work live.
The sixpanel.json it starts with, so you know what the app gets:
| What | How |
|---|---|
| Database | PostgreSQL. DATABASE_URL (the database owner) reaches only the build and the deploy commands; the running app gets APP_DATABASE_URL, a role of its own. |
| Migrations | npm run db:migrate as a deploy command, after the build. A build that fails or runs out of memory never changes the database under the version that is live. |
| Secrets | APP_SECRET: you type it. CRON_SECRET: made by the panel. NEXT_PUBLIC_TURNSTILE_SITE_KEY / TURNSTILE_SECRET_KEY: optional, both empty means off. |
| Health check | /api/health |
Every other key (storage, email, payments, login providers) is set in the app's own admin, as the sixpanel.json chapter explains.
Good to know
- The code lives in the website's code folder, not in a release, so nothing the agent writes is lost at the next deploy. That folder is in the website's backups, and a restore waits while the agent is working.
- Tia can start this for you: tell her about the app in the chat. She writes the brief and leaves it waiting on this page with a link. You read it and press Plan it yourself. She never answers the question card for you and never puts the app live.
- A reseller's or a user's account cannot start a new app or use AI Coding: on this release AI Coding is the server owner's alone. No package can give it to an account.
- Mobile apps (Flutter) are not built here yet: the table says None for now.
Project notes
Each project and website has notes for AI Coding: its brief, its plan and its memory. AI Coding reads them before it works and writes what it learns into them, so the next session starts where the last one stopped instead of from nothing.
| File | What it holds |
|---|---|
docs/brief.md | what is being built and for whom, your answers and later instructions |
docs/flows.md | each flow a user goes through, step by step |
docs/test-matrix.md | what is tested, on which screens and devices, and how |
docs/checklist.md | the steps of the work, ticked as they are done |
decisions.md | each decision, dated, with its reason |
ai_brain/learnings.md | long-term lessons, short and dated, one a line |
ai_brain/active_context.md | where the work stands now |
ai_brain/projects/<name>.md | the facts of this project |
ai_brain/daily_logs/ | what was done each day |
AGENTS.md | how the notes are kept: the order they are read in, and what FLUSH does |
Where they are. Beside the code, never in it: in the project account's own AI Coding folder on the server (/opt/sixpanel/data/agents/<account>/workspace). They are never deployed and never committed in the code's repository. The running website cannot see them — not its PHP, its Node.js process, its workers or its scheduled tasks — so a website that is broken into cannot read your brief or plant a line in the memory AI Coding trusts. AI Coding, the project's Terminal and SSH reach them, as the project's own account.
Open them. On the project's AI Coding page, on the right → Project notes → Open the notes. A project with no notes yet shows Start the notes; the first AI Coding session starts them by itself as well. Choose a file, change its text and press Save the file; A new file… asks for its path (docs/roadmap.md). Remove the file asks first, and the file stays in the history. While AI Coding is working in the project the sheet only reads: change the notes when that turn has finished. Tia, the panel's assistant, can read the notes; she never changes them.
What it reads. Above the message box a line says what the next turn of this project will read — your brief, how many decisions and lessons, where the work stands, your standing instructions, how many of SixPanel's skills, and the manual. What it reads opens every layer in the order the coding program is handed them: SixPanel's rules for the project (or for a staging site), what the project is (its kind, framework, databases and, for a 6amMart shop, whether it is the untouched CodeCanyon code or AllsWeb's changed copy), the project notes, the repository's own committed AGENTS.md / CLAUDE.md, your standing instructions, the skills by name, and the manual. Only names and numbers are shown; none of them holds a password or a key.
A project that came with no notes: Write project notes. A website or project you imported has no brief yet, so its page offers Write project notes. One turn reads the code — it changes nothing in it, and is given none of the panel's tools — and drafts the notes: the brief, the flows, the decisions it could see, a checklist, a proposed AGENTS.md and where the work stands, in your language. Every guess is marked as assumed. Read the draft shows each file in its own box and what it says to you; correct anything wrong and press Looks right to save it. A file you had already written is kept as it is. A line that holds a secret is taken out of the draft and named. Discard throws the draft away; Stop ends a draft being written. It waits while a session's turn works in the project or its staging site.
Saved, and checked for a secret first. Every save is a step in the notes' own history (History in the sheet). SixPanel saves what AI Coding changed when each turn ends, and the session says which files were saved. In a project's shell, sixpanel commit --workspace -m "<message>" saves them sooner. Before every save the notes are checked for a secret: a private key, an API key or token of a known service, a password inside an address or after a name like DB_PASSWORD= (or define('DB_PASSWORD', …) as a wp-config.php writes it), a .env, wp-config.php, .npmrc or key file — and every password, key and token this project itself has, wherever it appears and even with no name beside it: its database passwords, its saved repository token and webhook secret, its Redis password, and each secret its settings or its .env hold. A save that holds one is refused, with each file and line named — never the secret itself — and the file stays as it was written until you take the secret out. A secret belongs in the website's settings, never in its notes.
FLUSH. Type FLUSH in a session: AI Coding updates ai_brain/active_context.md, adds the day's progress to ai_brain/daily_logs/ and the new decisions to decisions.md, and SixPanel saves them when that turn ends.
A staging site uses the notes of its production. Its sessions work in a copy of them; what a turn changed there comes back into the project's notes when the turn ends. A file that holds a link instead of text is left out, and the session names it.
In backups. Every files backup and every full backup holds every project's notes (Backups → What is inside a backup). Restoring a project or a website puts back its database and its files and leaves its notes as they are. To keep a copy of the notes somewhere else as well, connect a docs repository.
Connect your docs repository (optional). A private repository of yours — not the code's — can hold a copy of the notes, updated after every save:
- Make an empty private repository (for example
project-noteson GitHub). - In the sheet, under Docs repository, paste its SSH address (
[email protected]:you/project-notes.git; anhttps://address is turned into it) and press Connect. - SixPanel makes a key for that repository and shows it. Add it to the repository as a deploy key with write access (GitHub: the repository's Settings → Deploy keys → Add deploy key, tick Allow write access).
- Press Push now. From then on every save is pushed by itself, and the sheet says when the last push was made, or why it failed.
What is pushed is the notes as they are, one step per push; it is checked for a secret again before it leaves the server. A push is never forced: a repository with commits the notes do not have is refused. Disconnect removes the key from this server and leaves the notes and the repository as they are.
When the project is moved or deleted. While a move holds the project its notes stay on this server, as they are. They do not travel to the other server with the move yet — connect a docs repository to take them with you. Deleting the project deletes its notes and the key of its docs repository.
Staging first
A session works on one of two places, and the page says which on every session.
Staging site (recommended). The work is done on a private copy of the project — its own files, its own database, its own address. With a staging site ready, the session uses it. With none, the session makes one first: the ordinary staging site, on a branch of its own when the project is deployed from git, and your message starts when it is ready. If another turn is working at that moment — another session of the same project, or as many turns as this server runs at once — your message waits, the session says so, and it is sent when that turn has ended. A session that could not run at all (no provider that is ready, no engine installed) is refused before a staging site is made for it. Where this server has no temporary address to give a staging site (no AllsWeb account is connected, or its plan has none), the page asks for a domain of your own right there: point it at this server first, write it in, and the session makes the staging site on it. See Staging & Testing.
A custom app — a Node.js app, or a PHP app the panel cannot set up by itself — gets its copy not started: the agent's first job is to point the copy at its own database, the panel then looks through the whole folder, and when it finds nothing left that names production the session shows Start the staging site. Starting it is your press, never the agent's — and your word: start it only if the app uses the staging site's own database and no other, because the panel cannot see a password the app keeps encrypted or loads from somewhere else.
Where the panel could not look — the app's database is not on this panel, or production's password is one a search cannot find — the session shows no Start. The agent tells you what comes first (a second database, made where production's is), and you start the staging site on its Set up by hand card on the project's Staging & Testing page, which asks for your tick. See Set up by hand.
Production, directly. Offered only where the code does not come from git, and only behind an agreement you tick for that session: changes are made on the live website, and a mistake is live at once. The panel asks you to confirm it is you, and before the session's first message it saves the database and tells you when the files were last backed up — run a backup first if that was long ago. When the disk has less free than the database's size and a quarter — for a website with more than one database, all of them together — the session does not start and nothing is saved: the panel says how many MB the copies need and how many are free.
Where the code does come from git, production is not edited in place: the next deploy would refuse or undo the change. The page says so; work on a staging site and move the work from there.
Move the work to production
On a staging site that works on a branch, the right side of the session shows the git card of that staging site: the files that changed, Commit and push, and how far production is behind. Move to production opens the promote of that card — one job that backs up production's database, merges the branch, deploys, checks that production answers, and puts production back if any of that fails. Its result is written into the session. Once everything is committed and the card says the work is ready, Move to production is also under the conversation, where you read the program's last words. See Working on a branch and promoting.
Where there is no git, the page says that moving the work needs a repository: connect one on the project's Deploys page, then start a staging site on a branch of its own.
Skills
A skill is a set of written instructions for one kind of job, such as a security audit, that a coding program reads when that job comes up. The program has a shell and works as your project's account, so SixPanel takes skills from one place only.
- They come with SixPanel's own updates. AllsWeb reads every line of a skill, and of every later change its authors make, before it goes into a release, and signs the pack with the same key that signs SixPanel itself. Your server never downloads a skill from GitHub or anywhere else.
- What this release carries: security-audit, Cloudflare's security-audit skill (
github.com/cloudflare/security-audit-skill, MIT licence), with SixPanel's rules on top. It audits this project's own code, in this project's folder only. It sends nothing to the live website, reports a secret it finds without using it, and keeps its findings out of the project's folder. - Three ways to start, one per use case:
- sixpanel-new-project: a new product from your description. The program asks you ONE message of questions, with what this server already answers filled in (SixPanel, PostgreSQL, Node.js 26, the domain, storage and email kept in the app's own admin), writes the project's notes (brief, flows, test plan, checklist, decisions), builds in a fixed order and ends with a report. Going live stays your press.
- sixpanel-continue-project: a project that already has its notes. It reads them in their order and follows the project's own rules, and never redoes the setup.
- sixpanel-adopt-project: a repository that came here with no notes. It maps the code without changing it, writes the notes with every guess marked, and asks you once.
- SixPanel's own skills, written by AllsWeb for the way this server builds and deploys:
- sixpanel-json: writing and fixing a website's
sixpanel.json— what each key does, what waits for your yes, and the lessons real deploys taught (migrations after the build, no secret in the file, the five environment names). - nextjs-postgres: a Next.js app with PostgreSQL — the owner and app database roles, migrations in the deploy commands and never before the build, migrations that only add while the old version still serves, and a build that fits the server's memory.
- sixamart: a 6amMart shop, on the untouched CodeCanyon code or a changed copy — it reads which one it is from the shop's own files, never runs
config:cache(a cached config turns off live order tracking on the untouched code), and restarts PHP after an edit. - Four working methods from REA (
github.com/morluto/rea, MIT licence), written again by AllsWeb for a project on a SixPanel server. Each is read only when its job comes up: - ci-tests-audit: when a test suite passed but missed a bug, CI is slow or flaky, or you want proof that a test really fails when the code is wrong.
- perf-optimization: a slow page, query, build or AI feature, measured before and after on a staging site — never by loading the live website.
- release-notes: release notes or a changelog entry from the project's git history, in plain words for the people who use it. It never tags, publishes or deploys.
- agent-tool-design: the tools an AI assistant inside your own app may call — who may see each one, confirmation before a risky action, and checks on the server.
- reverse-engineer-anything: what a project's own build really contains, such as whether the browser bundle or the Android app carries a key. It works with REA's tools, so it is given to a session only when they are installed (Software → REA reverse-engineering tools, see below). Until then its card on AI → Skills says Not usable on this server yet, and its switch is not ticked and cannot be pressed;
sixpanel aicode skillsprints it asn/awith the same reason. - flutter-ci: a mobile app. This server does not build mobile apps (an Android build alone asks for 8 GB of memory, and iOS needs a Mac), so the skill writes a GitHub Actions workflow for the app's own repository: checks and tests, the Android APK and App Bundle on an Ubuntu runner, and an iOS build without signing on a macOS runner. Every action in it is pinned to an exact version. Signing and store upload stay your step.
- Where they are. Each time SixPanel starts, the panel checks the pack's signature against the key it trusts and copies it to
/opt/sixpanel/runtimes/skills/<pack id>/. Root owns every file there. The project's account can read them and can change none. - Checked before every use. Before a session is given a skill, the panel checks the whole pack again: the signature, every file's contents, owner and permissions, and that nothing was added, removed or replaced by a link. If anything differs, the session gets no skill at all, and the panel says why. The next restart or update of SixPanel puts the signed copy back.
- When the skill's authors publish something newer. Once a day at most, on a server where AI Coding is in use, the panel asks GitHub (reading only) whether the folder the skill comes from has changed since the version this release carries. If it has, it says: a newer upstream version exists — it comes with the next SixPanel update. Nothing is downloaded. AllsWeb reviews the change, and it reaches your server with an update.
Which skills a session gets
Every skill that comes with SixPanel is on until you switch it off. A session is given only the skills that are on and fit its project:
- sixamart only on a 6amMart shop, and sixpanel-json, sixpanel-new-project only on a website (never on a shop);
- nextjs-postgres only where the project's code is a Next.js app;
- flutter-ci only where the project has a
pubspec.yaml; - reverse-engineer-anything only in a session that is given REA's tools (see below);
- every other skill on every project.
A skill that is off, or not for this project, is not handed to the program at all, and Claude Code is also told to refuse it by name. Each skill's one-line purpose is in the program's instructions, so it knows when to reach for one.
The Skills tab
Open AI → Skills.
- The first card says whether the skills on this server match the signed release. If they do not, sessions get no skill, and the card says what was found. Press Repair to copy them again from the signed release. Check for newer versions asks GitHub now, reading only.
- One card per skill: what it is for, which projects it is used for, its Source (the repository it came from), its Version (the commit it is pinned to) and its Date. The switch turns it on or off for every project on this server, from the next turn.
- A project's own skills. Choose a project or website, then switch on Use this project's own skills. It is off by default: the website itself can write its folder, so only skills committed in its repository (
.claude/skills/<name>/or.agents/skills/<name>/) are used, and only while this is on. The panel copies them out of the website's reach before every turn. The card lists what the repository has committed. A staging site follows its project's switch. A skill's header keeps only its name, description, license and metadata: it cannot pre-approve a command or run a hook. Deleting the project or website switches this off, so a new one with the same name starts with it off too. - With Codex, a skill the website put in its own folders is switched off. Before each Codex turn the panel lists, as the website's account, every
SKILL.mdin.agents/skillsor.codex/skills(the project's folder up to its repository) and in the account's home, and switches each one off for that turn. When there are more than one turn can switch off, Codex does not start and the message names the folder to clean. When the folders cannot be checked, Codex does not start either, and the message says why. Claude Code is not handed these folders at all.
Only you, the owner, see this tab. A temporary login, the demo, and a reseller or user account do not. Tia can read it and change nothing.
From the server's command line, as root:
sudo sixpanel aicode skills # each skill on, off or n/a, its source, and whether the copy is intact
sudo sixpanel aicode skills repair # copy the skills again from the signed releaseHealth shows the same in its AI Coding skills row, with the repair when one is needed.
REA's reverse-engineering tools
REA (github.com/morluto/rea, MIT licence) is a set of analysis tools for software you own or may test: your own built website bundle, your own release archive, an app package your own CI built. Never someone else's software. The reverse-engineer-anything skill says the same to the coding program, and it refuses the rest.
Install it on Software (under Tools): REA reverse-engineering tools → Install. How it is installed and checked is in Software → REA reverse-engineering tools.
What a session gets, once it is installed:
- REA's tools, as an MCP server of the session, and the reverse-engineer-anything skill with them — never one without the other.
- With Claude Code only. Claude Code asks you before each REA call, in the same card as any other action (Bypass, which you choose yourself, asks about nothing). Codex cannot ask anybody before a call, so a Codex session gets neither the tools nor the skill.
- REA runs as the project's own account, inside the turn, never as root: it reads exactly what that account may read, so it cannot see another project or website.
- Nothing of REA's own set-up runs: it does not change the coding program's settings and nothing is approved in advance.
- REA's build computers (its tools that start Docker containers, install packages into them and have a model judge the result) are refused in every session, in every mode, Bypass included: they do not read software, they run it.
- Native programs and Android packages need one of REA's optional engines, each its own item on Software once REA is installed: Ghidra for REA and JADX for REA (about 1 GB and up to 1.3 GB more memory while a turn uses one, held to what the server's turn has room for — a 4 GB or a real 8 GB server has room for one of them; a server that reports 4.3 to 4.9 GB of memory (it runs a single turn), or about 12.6 GB and more, for both; Ghidra on amd64 servers only). A session is told where the installed ones are; without them REA still reads JavaScript, archives and app packages. See Software → REA's engines.
- On your own projects and websites. A project or website that belongs to a reseller or user account gets REA's tools only when that account's package includes them: the switch AI Coding: REA's reverse-engineering tools on Accounts → Packages (
reaToolsin the API), off unless you tick it. A reseller's user needs it in its reseller's package too, so unticking it there takes it from that reseller's users at once. A staging site follows the project or website it was copied from: a session on an account's staging site gets REA's tools only when that account's package has them. A project whose record cannot be read, or a staging site whose production is gone, gets none. The Skills tab, under A project's own skills, says for the project you pick whether its sessions get REA's tools, and why not: not installed, its folder not safe, or the package (with the account's name) that leaves them out.
What it costs. Once REA is installed, every Claude Code turn on a project that gets its tools starts REA's server when the turn starts, whether or not the turn calls REA: about 400 MB of memory for as long as the turn runs, inside the turn's own memory limit, and a few seconds more before the turn begins. The descriptions of REA's tools are kept short for the coding program, but there are more than two hundred of them. If you do not use REA, remove it, and turns start as they did before.
Remove it on the same row; a session started after that gets neither the tools nor the skill. While a turn is using REA, Remove is refused with the reason and nothing changes: press it again when the turn has ended. REA's install and removal, and its engines', run one at a time: while one runs or waits, another is refused with the name of the one running.
What it cannot do yet
- Undo one turn. A staging site and git are the safety here (Create with AI keeps its own Undo).
- Move a staging site's changes to production without git.
- Work while the project is being moved to another server, or while its staging site is being made or refreshed — the page says why, and sessions start again when that has finished.
- Run as root, or outside the one project it was opened in.
How to check it worked
- The server's AI Coding page shows This server has what AI Coding needs and a version on the program's card.
- A session ends with Done and the time it took; every change it made is a row you can open.
- On a staging site, open the staging address from the right side and look at the change before you press Move to production.
- Project notes → Open the notes: after a turn that changed them, History has a step Notes from an AI Coding turn, and the session said which files were saved.
If it went wrong
- "Upgrade the server first" — the server has less than 2 GB of memory or 1 GB of free disk. Add memory or free space; nothing else unblocks it.
- "… is not installed on this server yet" — press Install. If the job fails, its log says why; a version already in use stays in use.
- "… is not ready for coding" — the provider is a plan that is not signed in, or a provider whose last check failed. Open AI → Providers.
- A newer version is held back — nothing to do: AI Coding works on the version in use. The server's AI Coding page lists the checks that did not pass.
- A turn "Stopped with an error" — the sentence under it is the reason (the provider was overloaded, the limit of your plan was reached, …). Press Try again at the end of the conversation: the message goes back in the box, and you press Send. The session continues where it was.
- "The staging site could not be made" — nothing was sent to the agent. Watch the log says why; Start again opens a new session with the same message in the box.
- "This session could not be read" — the panel did not answer (it may be restarting). Press Read again.
- "The connection to the server was lost. Reconnecting…" — the browser takes it up again by itself; the session keeps working on the server meanwhile. When it says the connection is closed, press Read again.
- The panel was restarted while it worked — that turn ended; the session says so, and your next message continues it.
- "Not saved: this looks like a secret", or a session that says The notes were not saved: … line … — that line holds a key, a token or a password. Take it out in Project notes (or ask AI Coding to) and save again; the rest of the notes is saved with it.
- "The docs repository refused the key" — add the key the sheet shows to that repository as a deploy key with write access, then press Push now.
- "…has commits these notes do not have" — the repository was used for something else. Disconnect it and connect an empty one.
Something unclear?Ask Tia