Skip to main content

MWD: You No Longer Write Code

· 5 min read
MicrowiseAI Team
MicrowiseAI Team
Developers @ MicrowiseAI

Let me be honest.

I no longer write code myself. I don't type CLI commands. I don't click deploy buttons.

AI does it.

I design the structure, provide direction, and review results. That's it.

"So what do you actually do?"​

Good question.

My typical day:

09:00  "Today's tasks: payment refactoring, user new feature, fix 3 bugs"
09:05  To AI-1: "Refactor payment-package. This direction."
09:06  To AI-2: "Add this feature to user-package."
09:07  To AI-3: "Fix these bugs."
09:10  Go get coffee

10:00  AI-1: "payment-package@1.2.0 deployed"
10:30  AI-2: "user-package@2.1.0 deployed"
11:00  AI-3: "Bugs fixed, 3 packages deployed"

11:30  Review results
12:00  Lunch

What I did: Provided direction, reviewed What AI did: Wrote code, tested, deployed, managed versions

Why this works: MWD​

For this workflow to work, one prerequisite is needed:

AI must be able to fully understand its assigned domain

If you tell AI "fix this" in a monorepo with 1000 files?

  • AI: "Uh... I don't know where this file is used..."
  • AI: "Will fixing this affect that side?"
  • Result: Wrong fixes, new bugs

Microwise Development solves this problem through structure.

One Package = One Repository = One AI's Complete Territory

The Core: "Hand over" packages to AI​

Traditional mindset​

"I manage this code, AI assists me"
     ↓
AI: Helper tool

MWD mindset​

"AI owns this package, I provide direction"
     ↓
AI: Assigned developer

Can you feel the difference?

The Power of Parallelism​

One AI isn't enough. I typically run 3-5 AI sessions simultaneously.

┌─────────────────────────────────────────────┐
│                   Me (Manager)              │
│                                             │
│  "Do A, Do B, Do C, Do D"                   │
└──────┬────────┬────────┬────────┬───────────┘
       │        │        │        │
       ▼        ▼        ▼        ▼
    ┌─────┐  ┌─────┐  ┌─────┐  ┌─────┐
    │AI-1 │  │AI-2 │  │AI-3 │  │AI-4 │
    │     │  │     │  │     │  │     │
    │pkg-A│  │pkg-B│  │pkg-C│  │pkg-D│
    └─────┘  └─────┘  └─────┘  └─────┘
       │        │        │        │
       ▼        ▼        ▼        ▼
    Deploy   Deploy   Deploy   Deploy

Is this possible in a monorepo?

AI-1: Modifying src/moduleA/...
AI-2: Modifying src/moduleB/...
AI-3: Need to modify src/shared/utils.ts...
AI-4: I also need to modify src/shared/utils.ts...

→ Conflict
→ Wait
→ Merge hell

In MWD?

AI-1: package-a/ completely independent
AI-2: package-b/ completely independent
AI-3: package-c/ completely independent
AI-4: package-d/ completely independent

→ Conflicts structurally impossible
→ Full parallelism
→ First to finish, first to deploy

Tools? AI uses them​

I don't run git-nested myself. I don't run mwd-lint myself. I don't run gitlab-publish myself.

AI does it.

Me: "How's payment-package looking?"
AI: (runs git-nested) "3 files modified, tests pass"

Me: "Package size okay?"
AI: (runs mwd-lint) "18 files, within threshold"

Me: "Deploy it"
AI: (runs gitlab-publish) "payment-package@1.2.1 deployed"

I just see the results.

"What if there's no tool?"​

I tell AI to make one.

Me: "Need a tool to update dependencies across multiple packages at once"
AI: "What features do you need?"
Me: "When package A version bumps, auto-update dependent packages B, C, D"
AI: (develops tool)
AI: "Created dependency-sync@0.1.0"
Me: "Good, use that from now on"

AI creates the tools, AI uses the tools.

Real Structure​

One of the projects I manage:

integrated-session-tools/
├── packages/           # 40+ independent packages
│   ├── core/
│   ├── adapter-claude/
│   ├── adapter-cursor/
│   ├── messenger/
│   └── ...
├── projects/
│   ├── monitor/
│   └── ...
└── experimental/

40 packages. Each an independent Git repository.

Packages where I write code directly: 0 Packages AI handles: 40

My Role​

1. Design Structure​

"Split this feature into a new package"
"This belongs in core"
"Let's go with adapter pattern"

2. Define Boundaries​

"user-package and payment-package only share types"
"No direct dependencies"

3. Distribute Work​

"AI-1: Improve adapter-claude"
"AI-2: Fix adapter-cursor bugs"
"AI-3: Create new adapter-copilot"

4. Review​

"This structure looks good, approved"
"This direction is off, adjust to this"

5. Make Decisions​

"Let's go with this tech stack"
"Apply this pattern"
"Let's do this later"

Writing code: No Running CLI: No Clicking deploy: No

Why This Works​

1. Small Packages​

50 files or less. AI understands everything completely.

2. Explicit Boundaries​

{
  "dependencies": {
    "types-user": "1.0.0"
  }
}

AI knows the exact scope of impact.

3. Independent Repositories​

Can't accidentally touch other packages.

4. Version-based Communication​

AI-1: "Deployed types-user@1.1.0"
AI-2: (checks package.json) "Got it, I'll work based on 1.1.0"

The Future​

Now:

1 Human (Manager) + N AI (Developers)

Soon:

1 Human (Direction) + 1 AI Manager + N AI Workers

Manager AI handles structure design and work distribution. I just say "build something like this".

MWD is the infrastructure for this future.

Getting Started​

Mindset Shift​

❌ "AI helps my coding"
✅ "AI codes, I design"

Structural Separation​

Big monorepo? Break it up. Into sizes AI can fully own.

Build Command Chain​

Me → AI: "Modify this package like this"
AI → Me: "Done, deployed"

AI figures out the tools on its own.

Conclusion​

Microwise Development is not about
"how do I manage code" but
"how do I delegate work to AI".

Your role is no longer code writer. You're an architect. You're a manager. You're a decision maker.

AI writes the code.

This post was written by AI. I only provided direction.