Virtual Collaboration Actually Works

When we started Kohaku Lab, we didn’t set out to prove anything about remote work or virtual teams. We just wanted to build cool AI/ML projects together. But along the way, we’ve learned that virtual collaboration isn’t just “good enough” - it can be genuinely great.

The Skepticism

People often assume distributed teams face insurmountable challenges:

“How do you coordinate across time zones?”
“Don’t you lose productivity without in-person meetings?”
“Isn’t communication harder remotely?”

Fair questions. Here’s what we’ve found.

What Actually Works

Asynchronous Communication Is a Superpower

Time zones aren’t a bug - they’re a feature. When someone in Taiwan finishes their work day and pushes code, someone in Europe wakes up and reviews it, then someone in the US picks up the next task.

We get continuous progress around the clock.

Key tools:

Discord channels, threads, and forums for async discussions
GitHub for code hosting and reviews
Good documentation (because you can’t just tap someone on the shoulder)

Deep Work Over Meetings

No conference room means no meetings (mostly). Instead:

Written proposals and RFC documents
Thoughtful async code reviews
Focused work time without interruptions

When we do need real-time sync, we use video calls. But they’re the exception, not the default.

Documentation Becomes Essential

Can’t rely on “tribal knowledge” when the tribe is scattered across continents. This forces us to:

Write better docs
Comment code more thoroughly
Maintain clear project wikis
Record decisions in issues and PRs

Ironically, this makes our projects more accessible to new contributors than many co-located teams.

What Doesn’t Work

Assuming Everyone’s Available

“Quick question” doesn’t exist when “quick” might mean a 12-hour delay. We learned to:

Provide full context in every message
Anticipate follow-up questions
Make decisions with incomplete synchronous input

Real-Time Pair Programming

It’s possible, but scheduling is a pain. We do more:

Async code reviews
Recorded walkthroughs
Detailed PR descriptions

Traditional “Collaboration” Overhead

Here’s a controversial take: when individuals are powerful enough to handle 100k+ line codebases with agentic coding tools, traditional in-person collaboration can become a bottleneck.

Our method is simpler: One person focuses on one project or task at a time. No multiple people stepping on each other’s toes, no coordination overhead, no “too many cooks” problems.

Instead:

Clear ownership of tasks and projects
Deep, focused work without coordination overhead
Async handoffs when someone needs input
Discord threads for specific technical discussions

The Unexpected Benefits

Global Perspective

Team members from different countries bring different perspectives, different approaches to problems, and different areas of expertise.

Forced Clarity

Remote work punishes vague communication. This made us:

Write clearer code
Articulate ideas better
Think through proposals more carefully

Focus on Results

Can’t measure productivity by hours in office. We focus on:

Code shipped
Bugs fixed
Features delivered
Impact created

Tools That Help

Our stack is simpler than you’d think:

For Code:

GitHub - That’s it. Code hosting, PRs, issues.
CI/CD pipelines? Not 100% needed. Nice to have, not essential.
VS Code Live Share? Never use it. Everyone works solo.

For Communication:

Discord - This is the key.
- Channels for different projects
- Threads for focused technical discussions
- Forum channels for longer-form discussions
- Brief communication about PRs, issues, new code
- If everyone engaged accepts → merge/modify
- Async by default, real-time when needed

The Real Key: Different Info, Different Channels

Here’s what actually matters: matching information type to the optimal medium.

People can see multiple things at the same time - your computer has multiple windows open, right? So:

Code changes? → GitHub PR + brief Discord message
Architecture discussion? → Discord thread
Quick question? → Discord channel
Formal documentation? → GitHub Wiki/README
Design decisions? → Discord forum or pinned message

No specialized “remote collaboration tools” needed. No VS Code Live Share. No complex CI/CD orchestration. Just GitHub for code, Discord for communication.

When you keep it simple, it works.

The Human Element

Technology enables collaboration, but people make it work. We’ve found that successful virtual teams need:

Judge by Code, Not Promises

You can’t see people working. You can only see their code. That’s actually liberating - results matter, not hours logged or how busy someone looks.

If something’s not done? No blame, no pressure. Just:

Assign it to someone else
Do it yourself
Let it wait

Everyone’s an enthusiast with their own life. Day jobs, families, other commitments come first.

Communication: Less Is More

Over-communication is exhausting and doesn’t work async. Instead:

Write clear code
Document decisions when they matter
Ask questions in Discord when stuck
Don’t expect immediate responses

If something’s important, it gets done. If it’s urgent, someone steps up. No need for status updates or check-ins.

Shared Passion (Not Obligation)

We’re building this because we love it. When it stops being fun, people take breaks or move on. That’s fine.

No guilt about being “late.” No pressure to perform. Just:

Work on what interests you
Ship when you’re ready
Help when you can
Take breaks when you need

And this applies to you too, reader. If you’re feeling burnt out or your interest is dropping - take a break. Seriously.

Everyone is human. Forcing yourself to work when you’re not feeling it produces bad code and kills motivation. Taking breaks isn’t laziness - it’s how we stay productive and creative long-term.

We’ve found that people who take breaks when they need them actually ship better work faster than those who grind through burnout.

Respect for Real Life

Just because you’re awake doesn’t mean everyone else should be. Everyone here has:

Day jobs that pay the bills
Personal lives and commitments
Other projects and interests

Kohaku Lab is the fun side project, not the main gig.

Advice for Virtual Teams

Based on our experience:

Write everything down - If it’s not documented, it doesn’t exist
Embrace async - Most things don’t need real-time discussion
One person, one task - Avoid coordination overhead by giving clear ownership
Use Discord effectively - Channels, threads, and forums beat endless meetings
Focus on outcomes - Measure what gets built, not when people are online
Trust individuals - With modern tools, one focused person can ship massive projects
Keep it casual - Formality doesn’t scale well virtually

The Agentic Coding Era Changes Everything

Here’s something most teams haven’t realized yet: when a single developer with AI coding assistants can build and maintain 100k+ line projects, the old collaboration model breaks down.

Traditional approach:

Multiple developers on same codebase
Constant coordination and merge conflicts
Meetings to stay aligned
In-person communication “essential”

Our approach:

One person owns a project or major feature
Use AI assistants for productivity
Ship complete implementations
Hand off clean, working code
Discuss architecture in Discord threads when needed

The result? Less coordination overhead, more deep work, better outcomes.

When individuals are this productive, in-person collaboration can actually slow things down. The bottleneck isn’t coding speed - it’s coordination overhead.

How We Use AI Coding Assistants

Not all AI usage is equal. Here’s our method that actually works:

1. Human Decides Everything Important

You - the human - decide:

Architecture and design patterns
Technology stack and dependencies
Solution approach and methodology
Implementation strategy
Design choices and trade-offs

AI executes your decisions, not makes them.

2. AI Does the Coding (Under Human Control)

AI writes the code, but you stay in control:

Direct the exact implementation
Specify design choices explicitly
Review and approve every step
Course-correct immediately when needed

Think of AI as an extremely fast junior developer who needs clear direction.

3. AI Documents, Human Verifies

AI can write documentation, but:

You must verify everything is correct
Check technical accuracy
Ensure docs match actual implementation
Fix any hallucinations or errors

Documentation is useless if it’s wrong.

4. Review Every Line

We encourage reviewing every line of AI-generated code:

Something feels weird? Ask AI to examine that specific part
Not sure about an approach? Get AI to explain the reasoning
Still uncomfortable? Modify it yourself

You’re not just accepting AI output - you’re actively reviewing and improving it.

5. Agentic AI Works, “Vibing” Doesn’t

AI is good when it’s agentic (autonomous task completion with your direction):

“Build this feature following this architecture”
“Implement X using Y approach”
“Refactor this to use Z pattern”

AI is bad when you’re just “vibing” (vague prompts, hoping for magic):

“Make it better”
“Fix the bugs”
“Optimize everything”

Be specific. Be directive. Stay in control.

Take Breaks (This Means You)

When you feel your interest dropping - take a break. Not tomorrow, not after this feature. Right now.

Everyone is human. Forcing yourself to code when you’re not feeling it:

Produces bad code
Kills creativity
Burns you out
Slows you down

Taking breaks when you need them isn’t weakness - it’s how we work better and faster.

Seriously: close your laptop, go for a walk, play a game, touch grass. The code will still be there when you come back, and you’ll solve problems faster with a fresh mind.

We’ve seen it repeatedly: people who respect their own energy and take breaks when needed ship higher quality work in less total time than those who grind through exhaustion.

One Person Touches Code, Everyone Contributes Ideas

Let’s be clear about what we mean by “one person per project”:

We’re NOT saying:

One person manages the whole project alone
One person makes all decisions solo
No collaboration on design

We ARE saying:

Only one person touches the codebase at a time
Everyone interested provides feedback, suggestions, discusses design choices
Multiple people collaborate on architecture and approach
But we don’t need multiple devs doing the actual implementation

Why? Because most code written by AI isn’t very difficult. The hard part is:

Deciding what to build
Choosing the right architecture
Making good design decisions
Reviewing and verifying the implementation

The actual typing of code? AI handles that. You don’t need 3 people pair-programming when 1 person + AI can implement what the group decided.

The workflow:

Team discusses approach in Discord
Someone says “I’ll handle this”
That person implements it (AI or human doing the actual coding - whichever is faster)
Team reviews the result
Iterate if needed

Sometimes AI codes it. Sometimes the person codes it directly - depends on the task:

Extremely difficult/novel code? Human might be faster
Extremely simple/boilerplate? Human might be faster
Everything in between? AI usually wins

Use whichever approach gets you to working code faster.

Collaboration on ideas, solo execution. It’s faster and produces better results.

The Future of Work?

We’re not saying everyone should work remotely. But for certain types of work - especially open-source development, research, and creative projects - virtual collaboration opens doors that physical location closes.

Want proof? Look at our projects:

7K+ GitHub stars
2M+ HuggingFace downloads
Active user communities
Real impact

All built by people who’ve never been in the same room, mostly working solo on their tasks, coordinating async through Discord.

Join Our Experiment

Think virtual collaboration sounds interesting? We’re always looking for passionate people to join Kohaku Lab.

No resume needed. No formal interview. Just:

Pick a project that interests you
Start contributing
Join the conversation

That’s it.

Related Posts:

Introducing Kohaku Lab

Connect With Us: