A few weeks ago I had a stupid idea.
What if instead of opening Claude Code, ChatGPT, Cursor, Gemini, GitHub Copilot and twelve terminal tabs...
I just had an office full of AI developers?
Not metaphorically.
An actual office.
With tiny pixel-art developers walking around, taking tickets, writing code, running tests and opening pull requests.
So naturally, instead of doing something responsible with my free time...
I built it.
It's called My Little Office.
👉 github.com/holasoymalva/my-little-office
And somewhere between building a cute pixel-art dashboard and watching an AI agent modify a real repository, I realized:
this project is much less about AI agents than I originally thought.
It's about what software development might look like when writing the code is no longer the main bottleneck.
And things get weird very quickly.
The original idea was simple.
I wanted something like this:
┌──────────────────────────────────────┐
│ MY LITTLE OFFICE │
│ │
│ 👨💻 DEV 🧪 QA 🧠 LEAD │
│ │
│ coding... testing... thinking │
│ │
└──────────────────────────────────────┘
`
Cute.
Fun.
Probably useless.
Except I didn't want the characters to just pretend they were working.
There are already enough dashboards showing fake activity bars moving from left to right.
I wanted the little developer sitting at the desk to be connected to an actual coding agent.
So that's what My Little Office became.
Each character can represent a different role and AI provider.
Right now I have agents like:
And underneath those characters you can run models from:
ChatGPT. Gemini. Grok.
The pixel characters are basically the UI.
Behind them there are actual agents doing actual work.
This is where the project stopped being a toy.
You can give an agent something like:
Fix the checkout crash when the shopping cart is empty.
The agent gets its own isolated workspace.
Then it can:
text
clone repository
↓
understand task
↓
inspect codebase
↓
make changes
↓
run project checks
↓
repair failures
↓
commit changes
↓
push branch
↓
open pull request
And suddenly the cute pixel developer walking toward a desk isn't just an animation anymore.
There is actually something modifying your codebase behind it.
That's the moment the project became interesting to me.
Because I've used AI coding tools constantly.
I've generated functions.
I've refactored code.
I've asked AI to debug things that I absolutely could have debugged myself but didn't feel like debugging because it was 6 PM.
We've all been there.
But this felt different.
I wasn't asking:
"Write this function."
I was asking:
"Solve this problem."
That sounds like a tiny difference.
It isn't.
At some point I noticed I wasn't coding.
I was doing this:
This bug belongs to QA first.
This refactor is risky, give it to the Tech Lead.
Run the tests before opening the PR.
Don't touch these commands.
The task is too vague. Ask for clarification.
Congratulations.
I accidentally promoted myself to middle management.
My parents must be proud.
But jokes aside, this changed how I started thinking about AI-assisted software development.
The interesting skill was no longer:
Can I write this code?
The interesting questions became:
Can I describe the problem correctly?
Can I define what "done" actually means?
Can I give an agent enough context without giving it enough power to destroy everything?
Can I verify the result?
Can I design a workflow where bad output gets caught automatically?
That's a completely different engineering problem.
This was probably the biggest thing I wish I understood before building this.
Connecting an LLM to a repository is relatively easy.
Give it tools.
Let it read files.
Let it modify files.
Let it run commands.
Boom.
You have an "AI software engineer."
Twitter thread completed.
$14M seed round incoming.
The difficult part comes five minutes later.
What happens when the agent writes garbage?
What happens when the tests fail?
What happens when it runs the wrong command?
What happens when two agents modify the same repository?
What happens when it confidently solves the wrong problem?
What happens when your brilliant autonomous developer decides that deleting half the application is technically a valid refactor?
That's why My Little Office ended up having things like isolated workspaces, command restrictions and verification gates.
An agent can work inside its workspace.
It cannot casually wander around your machine like:
bash
sudo rm -rf /
because apparently "please don't destroy my laptop" is now a software architecture requirement.
Welcome to 2026.
Here's another interesting side effect.
We spent years complaining about tests.
"Do we really need unit tests for this?"
"The feature is tiny."
"We'll add integration tests later."
Sure.
And "later" lives next door to documentation and technical debt repayment.
But agents change the equation.
If humans are writing every change, tests are useful.
If agents are writing changes autonomously...
tests become the fucking contract.
My Little Office has a simple rule:
If the project's verification commands fail, the task doesn't get delivered.
The agent gets the failure.
It can attempt to repair the problem.
If it still can't make the project pass, the task fails.
No green checks?
No pull request.
That sounds obvious.
But I think this is going to become a much bigger part of software engineering.
The better AI coding becomes, the more valuable verification becomes.
AI can generate infinite code.
Congratulations.
Now prove that any of it works.
I know.
Another AI article telling you developers aren't going anywhere.
Very original.
But hear me out.
I think something is disappearing.
And it's the assumption that a software engineer needs to personally write every implementation detail.
We already accepted this transformation before.
Nobody complains that programmers aren't writing assembly anymore.
Nobody says:
"Real programmers manually manage every memory address."
Well...
someone on Hacker News probably does.
But the rest of us happily moved up the abstraction stack.
Assembly became C.
C became higher-level languages.
Libraries replaced repeated implementations.
Frameworks replaced enormous amounts of boilerplate.
Cloud services replaced infrastructure we used to manage manually.
Stack Overflow replaced memorizing everything.
And now AI is replacing another layer of mechanical work.
That doesn't necessarily make software engineering less valuable.
It changes where the value lives.
This project made me think that the future developer environment might look less like:
text
developer → IDE → code
and more like:
text
developer
↓
intent
↓
agents
↓
implementation
↓
automated verification
↓
human review
↓
production
And before someone gets angry:
No.
I'm not saying nobody will write code.
I still write code.
You should still understand code.
You should absolutely know what your agents are doing.
Because reviewing AI-generated code without understanding software engineering is basically approving a legal contract written in a language you don't speak.
Good luck with that.
But I do think our relationship with code is changing.
Code becomes less of the product of our labor and more of the material we supervise.
And that's uncomfortable.
Especially for those of us who built our identity around being good at writing it.
Building this made me care less about memorizing APIs and more about things that sit one level above implementation.
Things like system design.
Architecture.
Debugging.
Product thinking.
Breaking vague requirements into executable tasks.
Writing good acceptance criteria.
Understanding security boundaries.
Designing verification.
Reviewing code critically.
Knowing when the AI's solution is technically correct but completely stupid.
That last one is going to be a very important senior engineering skill.
AI makes writing code cheaper.
Judgment doesn't become cheaper.
If anything, judgment becomes more valuable because suddenly your team can generate an absurd amount of code very quickly.
And somebody needs to decide whether that code deserves to exist.
This is another reason I built My Little Office.
I think side projects are becoming valuable for a completely different reason.
For years we built side projects to practice coding.
Todo app.
Weather app.
Twitter clone.
Netflix clone.
Todo app again because apparently humanity still hasn't solved lists.
But AI means we can experiment with entirely new software development workflows.
Don't just build another SaaS.
Build an agent that maintains it.
Build an AI QA engineer.
Build an automated code reviewer.
Build something that turns issues into PRs.
Build multiple agents and make them argue about architecture.
Seriously.
Make two models review each other's code.
Watch the chaos.
You'll learn more about where this technology fails than you will by reading another 97-post Twitter thread about "10 AI tools that will replace developers by Friday."
I don't know whether developers will work like this in five years.
Maybe we'll have entire AI engineering teams.
Maybe every developer will have five specialized agents.
Maybe IDEs will disappear into agent orchestration systems.
Maybe the whole thing collapses and we all go back to Vim.
That would be objectively hilarious.
But I wanted to experiment with the idea now instead of debating it endlessly.
That's what My Little Office is.
Not:
"Look guys, I solved the future of software development."
Absolutely not.
It's more like:
"This future might be coming, so I built the stupid pixel-art version of it to see what breaks."
And a lot breaks.
Which is exactly why it's interesting.
The project is open source.
And this is really why I'm sharing it here.
I don't want My Little Office to just be something people star, screenshot and forget about.
I want developers to experiment with it.
Clone it.
Add your own agents.
Connect your own repositories.
Change the roles.
Replace the models.
Make five QA engineers fight one developer.
Add Claude.
Add local models.
Make an agent exclusively responsible for deleting unnecessary abstractions.
Honestly, I desperately need that employee.
Try using it with a real side project.
See what happens.
Then tell me where it fails.
👉 GitHub: holasoymalva/my-little-office
If you build something weird with it, open an issue, contribute, fork it or show me what you made.
I would genuinely love to see where other developers take the idea.
After building this, I'm less interested in the question:
"Will AI replace programmers?"
I think that's becoming the wrong question.
A better one might be:
What does a programmer become when writing code is no longer the expensive part of building software?
Maybe we're becoming architects.
Maybe orchestrators.
Maybe product engineers.
Maybe extremely overpaid babysitters for stochastic parrots.
Probably some combination of all four.
But one thing hasn't changed.
It was never really about the code.
The code was just how we translated a problem into something a computer could execute.
The job was always:
understand the problem and make the machine solve it.
The machine is just getting much better at helping with the second part.
And I think that's pretty damn exciting.
Now I'm curious.
Would you actually trust an AI agent to open pull requests against your real codebase?
And more importantly:
What role would you add to the office?
A Security Engineer?
DevOps?
Designer?
That one senior developer who rejects every PR because "this abstraction feels wrong"?
Clone the project and let's find out.