🎧 Listen to this article: हिंदी · English · தமிழ் · తెలుగు · ಕನ್ನಡ · മലയാളം · ଓଡ଼ିଆ
🌍 Read this in your language: हिंदी · தமிழ் · తెలుగు · ಕನ್ನಡ · മലയാളം · ଓଡ଼ିଆ · 日本語 · 中文
Thirty machines sound like thirty times the speed. For one developer working alone, they can just as easily mean thirty times the confusion.
Today is November 20, 2026. AI coding agents and cloud build runners now make it cheap to run work on many machines at once, so a single developer can command what used to be a whole team's hardware. That raises a practical question many people are asking right now: if one person has 30 systems, how do they build one good application without drowning in merge conflicts? This is the story of a morning conversation that answered it.
A question over morning tea
It was early. Abhijit and Malay sat with their tea while a cool breeze came in from outside. On their laptop screens, build logs, branch graphs and error messages kept scrolling past like a slow river.
"Malay, I went to sleep thinking about something last night," Abhijit said, putting the mug down. "Remember what Papu bhai said? Even if you add more machines, at the end you hit the same delay at merge time. Then there was the talk about 30 hours, about a controller and workers, about ten machines. But my question is different. Say I have 30 systems and I work with an AI coding workflow in the cloud, with CI/CD. I am the only person. How do I use those 30 systems to build one good application, easily, without merge conflicts again and again?"
Malay smiled and adjusted the glasses. "That is a very good and very realistic question. Many people think more machines means the work gets done ten or thirty times faster. But when one developer works with 30 machines, the real problem is not machine power. It is coordination, context switching and architecture."
What Papu bhai got right, and what was off
"Honestly," Abhijit said, "after listening to Papu bhai's recording, it did not all sound correct. Nine or ten machines and still the same 30 hours? And the machines competing with each other at merge time?"
"First understand the feeling behind it," Malay said. "Papu bhai is speaking from experience. When many branches try to merge at the same time, you do get merge conflicts, waiting in a queue, and a bottleneck at integration. That part is real. But saying the machines compete with each other describes a technical process as if it were a human quarrel."
Malay counted off three points.
- More machines can cut time, but only for work that splits. If tasks can run in parallel and do not fight over one shared resource, more workers finish sooner. If every machine edits the same shared file, conflicts rise. The machines are not arguing. The code is colliding.
- Thirty hours is not a law. Assuming every plan takes 30 hours is a guess. Real time depends on how big the test suite is, whether a build cache exists, and how tangled the dependencies are.
- Learning is not deciding. Papu bhai said a system can learn but cannot decide. In practice, automated systems can make small rule-based decisions, such as retrying a failed job, routing work or raising an alert. High-risk, unclear or architectural decisions still need human judgement.
"Fine," Abhijit said. "But I still need my answer. My build is slow on one or two machines. I have 30. How should one person actually work?"
Thirty machines, four roles
Malay drew a small diagram in a notebook. "Start with one plain fact. You work alone. If you open 30 big branches on 30 machines at once, half your energy goes into context switching, which means jumping between tasks and reloading each one in your head. Which machine had which change, which branch threw which error: no single person can hold all that."
"So you do not give each machine a feature," Malay went on. "You give each machine a role."
- Two to four main development and integration machines. This is where you write code, test your branch and integrate it into the main line.
- Parallel test and build runners. A large share of the rest. When you push code, unit tests, integration tests, linting (automatic style and error checks) and builds are split across these machines and run side by side.
- Isolated preview, staging and load test machines. When a feature is ready, it runs here in a clean environment, so your main machine is never slowed down or broken by it.
- Background and experiment machines. Heavy indexing, benchmarks and risky experiments live here, away from everything else.
"That way the 30 machines are not all hammering one big file," Malay said. "They make separate kinds of work easier, in parallel."
Add-ons, an SDK, or both
Abhijit leaned in. "Should I build every module as an add-on? Or first make an SDK, then build each feature separately and connect it to the main app? Which one cuts merge conflicts most?"
"Now that is the real architecture question," Malay said. "For one person, a monolith, where everything is knotted together in one place, is the hardest. Add-ons and an SDK are both good, but they do different jobs."
The add-on or plugin approach. Each new feature is built as an independent add-on, plugin or package. While working on one add-on, you rarely touch the core files of the main app, so merge conflicts drop sharply. Builds get faster too, because you build and test only that add-on instead of the whole application.
The SDK approach. First you build a clear, stable SDK for the main application. An SDK, or software development kit, here means the contract that features talk through: shared types, events, hooks and APIs. Each feature is then built against that SDK and registered with the main app at the end. A bug in one feature does not bring the whole app down, and different features can be built on different machines or branches.
"For one person," Malay said, "the best plan combines them: a small core, a stable SDK, and independent feature modules. Keep the core and the SDK steady. Then build one feature at a time as its own module and connect it at the end."
A layout for that idea can be as simple as this:
app/
core/ # small and rarely changed
sdk/ # the contract: types, events, hooks, API
modules/
billing/ # code, UI, logic and tests for one feature
reports/
notifications/
How Abhijit sets it up
Abhijit asked for daily rules. Malay turned them into steps.
Step 1: Freeze a small core and write the contract first
Decide what the core does and keep it small. Before two modules talk to each other, agree on the interface or schema between them. When implementations later grow apart, they still connect cleanly, because both followed the same contract.
Step 2: Slice each feature vertically
Put everything one feature needs, its code, UI, logic and tests, inside its own folder or package. Shared files should be few, small and stable. The fewer shared files you edit, the fewer merge conflicts you get.
Step 3: Assign machine roles, not machine features
Keep your hands on two to four development machines. Point the CI pipeline at the runner machines so tests and builds spread out automatically. Send finished features to staging machines and keep experiments on their own boxes.
Step 4: Merge small and often
Do not sit on a big change for 10 or 15 days. Merge small working pieces quickly. A conflict that appears after one day is small and easy to fix. One that appears after two weeks is a long afternoon.
Step 5: Make builds incremental
A big reason builds are slow is doing a clean build and running every test every time. Use a dependency cache and a build cache, and run tests only for the modules that changed. That alone often saves more time than adding machines.
Step 6: Give AI coding agents a narrow scope
If an AI coding tool runs in your cloud or CI workflow, do not let it change the whole repository at once. Give it one module or a few named files, a clear written specification, and review its output as a small diff. One agent per module, working inside that module's folder, rarely collides with another.
The evening notebook
By evening, Abhijit had filled several pages. "My confusion is gone," Abhijit said. "From Papu bhai's talk I kept one lesson: adding machines without a plan can increase both time and conflicts. But with modular add-ons and an SDK, small merges, build caching and a smart split of the 30 systems, the work becomes organised and much easier."
Malay laughed. "Exactly. Thirty systems are an opportunity, but only when the architecture is clean and you control the workflow, not the other way round. Start with a small core, an SDK and one module. Test that. You will see your confidence and your speed both go up."
Conclusion
More machines help a solo developer only when the work is split so it does not collide. Give each machine a role, keep a small core behind a stable SDK, build features as independent modules, merge small changes often, cache builds and test only what changed, and keep AI agents inside one module at a time. Then 30 systems stop being a source of chaos and become real speed.
Merits
- Role-based machines keep the main development machine fast and stable.
- A core plus SDK plus modules design sharply reduces merge conflicts.
- Per-module builds and tests finish much faster than whole-app builds.
- Small, frequent merges keep each conflict small and quick to fix.
- Narrow scopes make AI agent output easier to review and safer to accept.
Demerits
- Designing a stable SDK takes time up front before features move fast.
- Running 30 machines adds cost, monitoring and maintenance work.
- A badly designed contract forces changes across every module later.
- Build caches can serve stale results if they are not set up carefully.
- Splitting too finely creates many tiny modules that are hard to track alone.
Caution
This article is educational and told as a story. The characters, the folder names and the machine counts are illustrative placeholders; adapt them to your own project, tools and budget. Speed-ups from caching, parallel runners or AI agents vary widely between projects, so measure your own build and test times before and after any change, and verify tool behaviour in the official documentation before relying on it.
Frequently asked questions
- Do more machines make software builds faster? — Only for work that can run in parallel without fighting over shared files or resources; otherwise more machines can add conflicts and waiting.
- How should a solo developer use many machines? — Give machines roles: a few for development, most as parallel test and build runners, and the rest for staging and experiments.
- What causes most merge conflicts? — Many changes to the same shared files, often kept on long-running branches and merged late.
- Is a plugin architecture or an SDK better? — For one person, a combination works best: a small core, a stable SDK as the contract, and independent feature modules or add-ons.
- How do I make builds faster without new hardware? — Use dependency and build caches, build incrementally, and run tests only for the modules that changed.
- How often should I merge my branches? — Small working pieces, merged daily or close to it, keep conflicts small and easy to resolve.
- How do I keep AI coding agents from creating conflicts? — Limit each agent to one module or named files, give a clear specification, and review the result as a small diff.
Tags
#softwarearchitecture #mergeconflicts #devops #cicd #git #monorepo #plugins #sdk #aicoding #developerproductivity
API Security Testing Checklist
A practical workflow for testing authentication, authorization, input handling, business logic, and evidence without losing track of scope.
Free. No spam — unsubscribe in one click.


Responses
Sign in to leave a response.