Live on thinkn.xyz

Your AI dev team,
one message away

Send a PRD to Telegram. ThinknBot creates the GitHub repo, breaks it into issues, writes the code, opens PRs, and merges — all autonomously.

View Commands How it works
bot@thinkn.xyz — ~
$ create-project --name invoice-app --prd ./PRD.md
✓ GitHub repo created: thinkn-com/invoice-app
✓ Project registered in registry
✓ CLAUDE.md and agent settings generated
→ Starting full-flow agent...
$ session-status --project invoice-app --follow
✓ [#1] feat: add invoice schema and DB migrations
✓ [#2] feat: REST API for invoice CRUD
✓ [#3] feat: PDF export endpoint
→ [#4] feat: email delivery via SendGrid — in progress
$
26
CLI Commands
100%
Autonomous
nginx
Deployed on
0
Manual commits needed
Process

From idea to production
in minutes

The bot takes a plain-English PRD and drives the entire software development lifecycle.

STEP 01
📄

Write a PRD

Describe what you want to build in plain English. Send it via Telegram or drop it as a file. No special format required.

STEP 02
🧠

Bot plans the work

An AI planner reads the PRD, breaks it into GitHub Issues with labels, and queues them for execution. No hand-holding.

STEP 03
⚡

Code gets written

An executor agent picks up each issue, creates a feature branch, writes the code, commits, and opens a PR — automatically.

STEP 04
✅

Merged & deployed

PRs are reviewed and squash-merged. The code lands on main. Every stage is reported back to your Telegram chat.

Reference

CLI Command Reference

All commands run as the bot user. They're on PATH inside any tmux agent session.

📁 Project Management
create-project
Bootstrap a full project: GitHub repo, CLAUDE.md, agent session. Optionally starts full-flow if a PRD is provided.
create-project \ --name my-app \ --description "SaaS invoicing tool" \ --prd ./PRD.md \ --full-flow
list-projects
Show all registered projects with GitHub URLs, deploy info, and session status.
list-projects ── or ── list-projects --verbose
project-info
Deep-dive into one project: git status, open GitHub Issues, open PRs, session role.
project-info \ --project my-app
extend-project
Add a new GitHub Issue, update the PRD, or restart the agent session with a different role.
extend-project \ --name my-app \ --add-issue "feat: dark mode" \ --description "Toggle in user settings"
🚀 Automation Flows
full-flow
Launch an autonomous agent that plans → executes → merges in a loop until no open issues remain.
full-flow \ --project my-app # with new PRD full-flow \ --project my-app \ --prd ./v2-PRD.md
plan
Run only the planner — reads PRD.md and creates GitHub Issues without executing any code.
plan \ --project my-app # update PRD first plan \ --project my-app \ --prd ./PRD.md
run-task
Send a specific GitHub Issue number to the active agent session for immediate execution.
run-task \ --project my-app \ --task 7 # executes issue #7
review-code
Start a reviewer session that checks open PRs, leaves inline comments, and approves or requests changes.
review-code \ --project my-app
🖥 Session Control
session-status
Show the last N lines of the agent's output log. Use --follow to tail live.
session-status \ --project my-app session-status \ --project my-app --follow
session-send
Inject a message or command directly into a running agent's tmux window.
session-send \ --project my-app \ --message "focus on the auth module next"
session-kill
Terminate the tmux session for a project. The project registry and GitHub Issues are untouched.
session-kill \ --project my-app
assign-session
Kill the current session and restart it with a new role: executor, planner, or reviewer.
assign-session \ --project my-app \ --role reviewer
⚙️ Infrastructure & Deploy
deploy-setup
Issues SSL certs, generates per-subdomain nginx configs, creates PM2 ecosystem, and sets env vars. Each app gets its own PROJECT[-APP].thinkn.xyz.
# auto-discover apps/ subdirs deploy-setup --project my-app # explicit apps deploy-setup \ --project my-app \ --apps "web:nginx:apps/web,api:nginx:apps/api"
core-start
Start the core orchestrator session — a long-running Claude agent that handles top-level coordination.
core-start
start-all
Start the Telegram bot, agent watcher, and watchdog in their tmux sessions in one shot.
start-all
bot-start / bot-stop
Start or stop the Telegram bot process in its dedicated tmux session.
bot-start ── or ── bot-stop
Infrastructure

Subdomain deployment on thinkn.xyz

Every app gets its own HTTPS subdomain — no path prefixes, no port numbers, no manual nginx edits.

URL naming convention
Web / Frontend
→
PROJECT.thinkn.xyz
API / Backend
→
PROJECT-api.thinkn.xyz
Named app
→
PROJECT-dashboard.thinkn.xyz
Real example — equiti-superapp
 
https://equiti-superapp.thinkn.xyz https://equiti-superapp-api.thinkn.xyz
Wildcard DNS *.thinkn.xyz → 212.24.109.151 is already configured — no DNS changes needed per project.
What deploy-setup does automatically
1
Discover apps
Scans apps/ subdirectories or uses the --apps list you provide. Assigns a unique port to each app (persisted in config/ports.json).
equiti-superapp/web → port 3101 equiti-superapp/api → port 3102
2
Issue SSL certificate
Runs certbot certonly --webroot for each subdomain. Skips if cert already exists. Falls back to HTTP-only if certbot fails.
certbot certonly --webroot -w /var/www/html \ -d equiti-superapp.thinkn.xyz
3
Generate nginx site config
Creates /etc/nginx/sites-available/FQDN.conf with SSL, security headers, gzip, and a reverse proxy to the app's port. Symlinks it to sites-enabled/ and reloads nginx.
server { listen 443 ssl; server_name equiti-superapp.thinkn.xyz; location / { proxy_pass http://127.0.0.1:3101; } }
4
Write environment files
For web apps: writes .env.local with NEXT_PUBLIC_API_URL pointing at the API subdomain. Removes any basePath from next.config.*.
For API apps: writes .env with PORT and CORS_ORIGIN.
# .env.local (web) NEXT_PUBLIC_API_URL=https://equiti-superapp-api.thinkn.xyz NEXT_PUBLIC_WS_URL=wss://equiti-superapp-api.thinkn.xyz # .env (api) PORT=3102 CORS_ORIGIN=https://equiti-superapp.thinkn.xyz
5
Create PM2 ecosystem
Writes ~/.orchestrator/nginx/PROJECT-pm2.json. Each app entry has autorestart: true, log paths, and production env. Use pm2 start to launch.
pm2 start ~/.orchestrator/nginx/equiti-superapp-pm2.json pm2 status pm2 logs equiti-superapp-web
Full project creation timeline
From Telegram message to live HTTPS URL — what happens behind the scenes.
💬
Telegram → /new or create-project
You send a project name (and optionally a PRD) to the bot. The bot calls create-project --name PROJECT.
↓
🗂
GitHub repo created
gh repo create thinkn-com/PROJECT --private — repo is initialized with main branch and pushed.
↓
📄
CLAUDE.md generated
Agent config file written to the repo: deployment URLs (PROJECT.thinkn.xyz), GitHub Issues workflow, commit conventions, MCP tool reference.
↓
🧠
Agent session started
A Claude Code agent boots in a dedicated tmux session (agent-PROJECT). With a PRD it runs full-flow immediately.
↓
⚡
Issues → branches → PRs → merges
The agent loops through GitHub Issues autonomously. Each issue becomes a branch, a PR, and a squash-merge to main.
↓
🚀
deploy-setup → live on HTTPS
The agent (or you) runs deploy-setup --project PROJECT. Certs issued, nginx configured, PM2 started. App is live at https://PROJECT.thinkn.xyz.
Workflow

Inside a full-flow run

What the agent actually does — step by step — after you hit send.

📋

Check open issues

Agent queries GitHub for issues labelled todo. If none exist, it reads PRD.md and creates them first.

gh issue list --label todo --json number,title
🔀

Create feature branch

Checks out main, pulls latest, and creates a branch named after the issue number and title slug.

git checkout -b feature/issue-7-dark-mode
💻

Write & commit code

Implements the feature according to the issue body and PRD. Commits with Conventional Commits format — no emojis, no noise.

git commit -m "feat(ui): add dark mode toggle to settings"
🚢

Open pull request

Pushes the branch and opens a PR with a description that includes "Closes #N" so the issue auto-closes on merge.

gh pr create --title "feat(ui): dark mode" --body "Closes #7"
✅

Squash & merge

Merges the PR with squash strategy, deletes the branch, pulls main. Then loops back to step 1 for the next issue.

gh pr merge --squash --delete-branch
🔔

Telegram notification

Every stage change (start, PR opened, merged) sends a notification to your Telegram chat with a direct GitHub link.

Telegram Interface

Manage everything from chat

The bot has an inline keyboard UI — no need to remember command syntax. But slash commands work too.

/start
Main Menu Opens the interactive dashboard with Projects, Sessions, and System buttons.
/projects
Project List Shows all registered projects. Tap one to open its dashboard with action buttons.
/new
New Project Bot prompts for project name then creates the GitHub repo and registers it.
/attach <name>
Attach to Project Sets the active project. All subsequent messages go directly to that agent session.
/status
System Status CPU, RAM, disk, nginx status, active tmux sessions — at a glance.
/sessions
Active Sessions Lists all running agent tmux sessions with a button to view live output.
/send <name> <msg>
Message Agent Inject a message into a running agent session directly from Telegram.
/shell <cmd>
Remote Shell Run a shell command on the server and get the output back in chat.
/help
Help Lists all available slash commands with short descriptions.

Project Dashboard buttons

When you tap a project from /projects, you get an inline keyboard with everything you need to manage it:

● Status 📝 Logs 🖥 Terminal 🔀 Git 🗂 Issues ➕ Add Task ▶ Run Task ▶▶ Run All 🧠 Plan 🔍 Analyze ⚙ Deploy 📄 PRD 🚀 Full Flow 🛑 Stop