DEV Community: Kabir Adm

I pointed a "team of AI agents" at a real feature request. It actually compiled.

Kabir Adm — Tue, 01 Sep 2026 02:19:40 +0000

I'll be honest, I clicked into this one ready to be annoyed. Every other week there's a new "AI dev tool" that turns out to be a chat window with a system prompt and a GitHub star-begging README. I've burned enough evenings on those to be suspicious by default.

But a friend pointed me at ohmyaistaffs last week — a self-hosted, single-binary thing that claims to take a plain-language request and hand you back a compiled, tested, running app, not just a pile of markdown or a scaffold with 40 TODOs in it. No account, no license key, free. That combination of claims (self-hosted + no login + "it actually compiles") was specific enough that I figured it was worth ten minutes to check if it was real.

Getting it running

No signup flow, no dashboard to click through. Just:

curl -fsSL https://ohmyaistaffs.io/install.sh | bash

That's it — it drops a single Go binary on your machine and serves its own UI locally. No Docker Compose file, no Postgres you have to spin up first, no "create an account to get your API key." If you already have Claude Code CLI installed and logged in, it'll piggyback on that session instead of asking you for a key at all. If not, it supports basically everything else too — Anthropic, OpenAI, Azure OpenAI, Bedrock, Vertex, Gemini, OpenRouter, Groq, DeepSeek, Mistral, xAI, or fully local via Ollama/LM Studio. Bring your own model, swap it later, nothing's locked to one vendor.

What actually happens when you give it a request

This is the part I expected to be underwhelming. It wasn't quite.

You type one sentence — I tried something boring on purpose, a small internal tool for tracking equipment loans — and instead of immediately vomiting out code, it comes back with clarifying questions first. Who can mark something as returned? Does overdue matter? Is there more than one location? It's a small thing, but it's the difference between "the model guessed and baked a wrong assumption into 12 files" and actually catching that stuff before code exists.

After that it works in three visible stages, and you can stop at any of them:

clarify — just the spec/requirements docs
design — spec + actual HTML screens, built from a shared design-token set (13 named color roles, one type scale, one spacing scale) so screens don't end up looking like five different apps mashed together
build — the real thing: data model, API wiring, tests, seed data

The UI represents this as agents sitting at desks on a little office floor with a task board (queued / working / in review / done), which sounds gimmicky written out like this, but in practice it's just a legible way to see which of the three roles — analyst, designer, engineer — is doing what, and there's a clear "waiting on you" indicator when an agent is stuck on a decision instead of silently guessing.

The part that actually got me

Anyone can promise "AI writes your app." The thing that made me trust this more than the average tool: the generated backend is plain Go stdlib, and the pipeline runs go build, go vet, gofmt, and go test against what it produces before calling a task done. It's not "trust me, the LLM said it works." There's a compiler in the loop. Storage is JSON files with atomic rename writes rather than some hidden managed DB you now depend on, and CRUD operations do real state-transition validation instead of the classic AI-demo move of stubbing everything as a 501.

Two other details worth mentioning if you're evaluating this seriously rather than just kicking the tires:

You can point it at an existing repo instead of starting from scratch. It lazily indexes the folder (keyword + link index, not a full copy), figures out how to run it — package.json scripts, go.mod, a Makefile target, whatever — and gives you a live preview against your actual codebase.
Cost tracking is per-agent and per-call, attributed the moment the provider reports token usage, not estimated after the fact. If you're paying per token across three agents that all get to call out to a model, that matters more than it sounds like it should.

What it's not

It's not magic, and it's not going to replace someone thinking about your actual product. It's also clearly early — there's dormant licensing/billing scaffolding in the codebase for a future paid tier that isn't wired up to anything yet, which tells you it's a project still figuring out its shape, not a finished commercial product with a pricing page. If you need enterprise SSO or a hosted managed version today, this isn't that — it's a binary you run yourself.

But for the specific job of "turn a vague internal request into a working prototype I can poke at before committing to a real design doc," it did what it said, and the fact that the output has to survive go build before it's called done is the reason I'd actually reach for this again instead of just letting it collect dust next to the other tools I tried once.

If you want to try it yourself, it's still just:

curl -fsSL https://ohmyaistaffs.io/install.sh | bash

Curious if anyone else has run it against something bigger than a toy internal tool — drop a comment if you have, I'd like to know where it breaks.

How I Built a Full Xiangqi Game in a Week Using GitHub Copilot (Instead of 3 Months with a small Team)

Kabir Adm — Sun, 01 Mar 2026 04:19:12 +0000

Three years ago, building a Xiangqi (Chinese Chess) game required a team and months of development.

Today, I rebuilt it almost entirely by myself — with the help of GitHub Copilot.

You can try the game here: Cờ Tướng

This article is not about hype. It's about the real workflow changes, practical lessons, and how AI fundamentally changed how I build software.

The Old Way: 3 Months, 3 People

Previously, building a Xiangqi game required:

2 developers
1 designer
~3 months of work

Scope included

Core Screens

Login page
Register page
Lobby
Gameplay screen
Table management system

Designer workload (~1 month)

The designer had to create:

Board textures
Piece designs
UI layout system
Lobby visuals
Buttons, panels, effects

Game UI design is time-consuming because everything must feel immersive and consistent.

Development workload (~2 months)

The developers focused on:

1. UI implementation

Building pixel-perfect UI from design files.

2. Multiplayer system

Room creation
Joining tables
Synchronizing moves
Handling reconnects

3. AI engine

This was the hardest part.

We had to implement:

Move generation
Position evaluation
Difficulty levels
Avoid obvious blunders

4. State management & bug fixing

Handling all edge cases:

illegal moves
disconnections
game ending logic
synchronization errors

Even releasing a basic playable version took around 3 months.

The New Way: Just Me and GitHub Copilot

Recently, I decided to rebuild the game completely from scratch using GitHub Copilot.

No designer.
No second developer.

Just:

Me
Copilot

My role shifted from writing code → directing code.

My workflow became:

Think of an idea
Write a prompt
Review Copilot's code
Fix or refine with prompts
Repeat

This dramatically reduced development time.

How I Actually Use Copilot

Copilot works best when treated like a junior developer that is extremely fast, but needs direction.

Not magic. Not perfect. But incredibly productive.

The key is how you prompt.

Lesson 1: Build UI One Component at a Time

Bad prompt:

Create a full lobby UI for my game

Result: messy, generic, unusable.

Good prompt:

Create a TableManagementPage with:

wooden texture background

table list with pagination

each table has name, time limit, turn limit

user can click to join a table

use React and Css module

This produces much higher-quality results.

Why?

Because Copilot performs better when the scope is clear and focused.

Lesson 2: Let Copilot Use Your Existing Architecture

Once your frontend structure exists, backend becomes extremely fast.

Example prompt:

Create API endpoints for TableManagementPage

Copilot automatically generates:

GET /api/tables
POST /api/tables
JOIN table endpoint
validation logic
models

Because it already understands your codebase.

You don't need to describe everything.

Context is enough.

Lesson 3: Designer Work Reduced by 90%

Before:

Designer needed ~1 month to create full UI.

Now:

I simply prompt:

Create a wooden texture Xiangqi board UI with traditional Chinese style

Then refine:

Make the board darker
Add hover highlight
Add move animation

Copilot generates usable UI instantly.

I only adjust small details.

Lesson 4: AI Handles Most Boilerplate

Copilot excels at writing:

React components
API endpoints
state management
validation logic
repetitive UI code

This eliminates most of the tedious work.

I focus only on:

architecture
game logic
final decisions

Lesson 5: Development Becomes Exponentially Faster

Old process:

Think → Code → Debug → Repeat

New process:

Think → Prompt → Review → Done

The difference is massive.

Tasks that took hours now take minutes.

Example: Creating Table Management System

My actual workflow:

Step 1: Prompt Copilot

Create TableManagementPage with pagination, wooden style, join button

Step 2: Copilot generates full React component

Step 3: Prompt backend

Create API for TableManagementPage

Step 4: Copilot generates endpoints

Step 5: Connect frontend & backend

Done.

Total time: less than 1 hour.

Previously: 1–2 days.

My New Role: From Developer → Director

I no longer spend most of my time typing code.

I spend most of my time:

thinking
designing architecture
reviewing AI output

Copilot handles implementation.

This is a fundamental shift.

What Copilot Is NOT Good At

Copilot still struggles with:

complex game algorithms
architecture decisions
long-term consistency
optimizing AI engine logic

You still need engineering experience.

Copilot accelerates developers.
It does not replace them.

What Used to Take a Team, Now Takes One Developer

Before:

2 developers
1 designer
3 months

Now:

1 developer
GitHub Copilot
dramatically less time

This is not theoretical.

This is production reality.

Final Thoughts

GitHub Copilot completely changed how I build software.

It removes most repetitive work and allows me to focus on what matters.

The future of development is not AI replacing developers.

It's developers using AI to build faster than ever.

If you're not using AI in your workflow yet, you're already behind.

If you have questions or want to discuss building games with AI, feel free to comment.

You can try the game here:
https://cotuong.club/