From Slack Messages to Pull Requests: How AI-Assisted Development is Changing the Coding Workflow

We've all been there. You're in back-to-back meetings when a teammate drops a critical bug report in Slack. Or you're reviewing a PR and spot a systemic issue that needs fixing across three different services. Or you want to tackle that migration before you head out for the day, but starting it in your IDE feels like overkill.

The reality of modern development is messy and non-linear. And traditional tooling—IDEs, CLIs, dashboards—assumes you're sitting down for a focused coding session. They don't handle the fragmented, interrupt-driven nature of real-world engineering.

That's where AI-assisted development tools are making a real difference. Rather than treating autonomous code generation as a standalone feature, the best platforms are embedding it directly into your workflow, whether you're working on your laptop, in a terminal, or jumping into a browser tab between meetings.

The Case for Browser-Based AI Coding

There's something elegant about reducing friction in your workflow. You don't need to fire up your IDE, clone a repo locally, or context-switch your entire environment just to handle a quick task. A browser-based interface lets you:

• Respond immediately to urgent issues without setup overhead
• Work across multiple repositories in a single conversation
• Collaborate asynchronously with your team through pull requests
• Stay mobile without losing capability

This matters more than it sounds. Every bit of friction in your workflow is a moment where you might defer work, lose context, or context-switch to something else. Removing that friction means more problems get solved faster.

Autonomy Without Blindness

The key difference between a useful AI coding assistant and a frustrating one is transparency and control. When you toggle on "autonomous mode," you're not just hitting a button and hoping for the best. A well-designed system should:

Ask clarifying questions first. Before writing a single line of code, the agent should probe your requirements, understand edge cases, and confirm its approach with you.

Show its plan. You should see the strategy before the implementation. This lets you catch misunderstandings early, before work goes off track.

Work in isolation. Every task should run in a clean, sandboxed environment where it can't affect other work or your production systems. When it's done, you review the code (just like any other PR) before merging.

Learn from feedback. The system should incorporate your code review comments into its future behavior. If you correct its error handling approach, it should remember that for the next task.

This is fundamentally different from shipping a black box. You're teaching an agent your team's standards and conventions, then gradually giving it more autonomy as it proves it understands them.

Cross-Repository Coordination: A Real Productivity Win

Here's a scenario that happens constantly in larger codebases: You need to update a shared library, and that means coordinating changes across five services that depend on it. Or you're adding a backend API endpoint and need to update the frontend client, web client, and mobile SDK all in sync.

Managing this manually is tedious. You're jumping between repos, keeping mental notes of what changed where, making sure all the PRs are coordinated and reviewed together.

An AI agent that understands your full codebase and can coordinate changes across multiple repos simultaneously is genuinely valuable. One conversation, multiple PRs, all logically connected. Your team reviews them together. Everything ships in sync.

Teaching Your Agent: Steering Files and Conventions

The most powerful feature of modern AI development tools is their ability to learn your team's patterns. Rather than accepting generic, one-size-fits-all code, you can establish your team's standards upfront:

• Architecture patterns you prefer
• Error handling conventions
• Testing standards and frameworks
• Naming conventions and code style
• Technology choices and dependencies

By storing these preferences in "steering files" (simple configuration files checked into your repo), every agent—whether running in the web interface, IDE, or CLI—operates with the same understanding of your codebase. It's like pair programming with an agent that actually knows your team's unwritten rules.

And as you leave feedback on PRs, the agent incorporates that guidance. "Always use our standard error handling" becomes reinforced behavior across all future tasks. This continuous feedback loop means the agent gets smarter and more aligned with your team over time.

Security and Isolation: The Details Matter

When you're giving an agent access to your code and repositories, isolation and permission control aren't nice-to-have features—they're essential. The right platform should:

• Run each task in an isolated sandbox that's created fresh and destroyed when done
• Give you granular control over what the sandbox can access (network resources, specific tools, base environments)
• Support enterprise identity management so administrators can control access at the org level
• Never allow one task's sandbox to affect another or your local environment

This is especially critical if you're working with regulated data, APIs with sensitive credentials, or multi-tenant systems. The architecture should make it impossible for work on one task to leak into another.

The Practical Impact on Your Team

When you step back and think about what this means for your team:

Bugs get fixed faster. Someone spots an issue in a PR review and mentions /kiro in the comment. The agent picks it up, codes a fix, pushes it as a PR. By the time the reviewer gets to it, the work is done.

Tedious refactoring happens without context-switching. That migration you've been putting off? Run it in a browser tab between meetings. Review the PR. Merge it if it looks good.

Async collaboration becomes smoother. Instead of waiting for someone to have time to tackle a task, it gets picked up immediately. Reviewers can focus on judgment calls and design decisions rather than basic implementation.

Your standards stay consistent. Because the agent learns from your feedback and steering files, code quality doesn't drift when work gets automated.

Getting Started: Lower Friction Than You'd Think

If this sounds compelling, the barrier to entry is actually pretty low. Many teams can get up and running in minutes:

1. Connect your GitHub account
2. Select the repositories you want to work with
3. Start a session and describe what you need
4. Chat with the agent about implementation, ask questions, iterate
5. When it looks good, generate a PR and review it like normal

For teams using enterprise identity systems (AWS Identity Center, etc.), administrators enable access at the org level, so individual developers don't need to manage credentials separately.

And if you want to get sophisticated with steering files and custom configurations, those are available—but they're optional. You can start simple and layer in more control as you discover what works for your team.

The Evolution of Developer Tooling

We're watching a fundamental shift in how developers work. The IDE will always exist for deep, focused coding sessions. CLIs will remain essential for automation and scripting. But there's a new space opening up in the middle—a place where quick tasks, cross-repo changes, and structured automation happen without the overhead of local development.

Platforms that unify these interfaces around a shared AI assistant are beginning to win because they reduce friction without sacrificing control or safety. Whether you start in your IDE, a terminal, or a browser, you're working with the same agent, the same steering conventions, and the same version of your codebase.

That's worth paying attention to.

What to Try First

If you're curious about this approach, pick something real from your backlog. Not a toy example—an actual bug, feature, or test suite you've been meaning to get to. See how the workflow feels. Notice where it saves time and where you still need to step in and guide the process.

The promise of AI-assisted development isn't about removing developers from the process. It's about removing friction, automating tedium, and letting humans focus on judgment, design, and strategy. The teams that figure out how to make that work will ship faster and with less burnout.