DEV Community: luc

What Happens When AI Agents Join the Sprint?

luc — Tue, 29 Sep 2026 14:51:20 +0000

Sprint planning usually assumes that developers are the ones doing the work.

But what happens when your team starts using AI coding agents?

A sprint could have:

A developer working on architecture
An AI agent implementing a feature
Another agent writing tests
A human reviewing and merging the results

Suddenly, planning isn't just about who has time. It's also about deciding which tasks can be delegated to agents and how humans should review their work.

I've been exploring Sharkly.ai for this kind of workflow. Its Plan feature helps organize project work, while Sprints provide a way to structure that work into focused cycles.

Plan: https://sharkly.ai/features/plan/

Sprints: https://help.sharkly.ai/docs/space/sprints

I think the interesting challenge isn't simply adding AI to sprint planning.

It's figuring out how to plan a sprint when both humans and AI agents are contributors.

Would you assign AI agents specific tasks and deadlines as part of your normal sprint?

Trello Was Built for Humans. What Happens When Agents Join the Team?

luc — Mon, 28 Sep 2026 13:47:00 +0000

Most developer project boards assume that the person assigned to a task is a human.

You create an issue, assign it to someone, move it through the workflow, and eventually mark it as done.

AI coding agents change that assumption.

A task could now be assigned to an agent to implement a feature, another agent could run tests or review the changes, while a developer coordinates the work and makes the final decisions.

At that point, a traditional Kanban board starts looking less like a workspace and more like a task tracker.

That’s why I’ve been exploring Sharkly.ai as a free AI-native alternative to traditional project-management tools. The interesting part is that AI agents can participate in the workflow alongside human teammates rather than being treated as a separate AI assistant.

For me, the bigger question is:

Should the next generation of developer project-management tools manage tasks—or manage collaboration between humans and AI agents?

How would you want your project board to handle AI agents?

AI Agents Need More Than a Prompt

luc — Fri, 25 Sep 2026 13:52:50 +0000

AI agents can already write code, analyze issues and complete tasks.

But once you have multiple agents working on a real project, another problem appears: coordination.

Who owns the task?
What context should the next agent receive?
Where does human review happen?

That's the problem space I'm exploring with Sharkly.ai — bringing humans and AI agents into the same project workflow.

How are you handling agent coordination in your projects?

5 Multiplayer AI Tools for Team Collaboration

luc — Thu, 24 Sep 2026 12:07:13 +0000

AI coding tools have mostly been built around the idea of one developer working with one AI assistant.

But that model starts to feel limiting when you have multiple agents working on different parts of the same project.

I’ve been exploring tools that approach this problem from different angles. Here are 5 worth looking at:

Sharkly.ai

Sharkly.ai focuses on the collaboration layer between humans and AI agents.

Instead of managing agents as isolated coding sessions, the idea is to have multiple agents participate in the same project while humans can assign work, coordinate tasks, and review what comes back.

For teams experimenting with agent-based development, I find this approach interesting because the problem isn't only “Can the agent write the code?” — it's also “How do we work with several agents without creating coordination overhead?”

CrewAI

CrewAI takes a more orchestration-oriented approach.

Developers can create teams of specialized agents with different roles, goals, and responsibilities. This makes it useful when a workflow naturally breaks into several autonomous tasks.

It’s particularly interesting for developers who want to build their own multi-agent systems programmatically.

Microsoft Copilot Studio

Microsoft Copilot Studio approaches agents from the enterprise side.

Teams can create agents and connect them to business data, applications, and existing workflows. The focus is less on building an experimental multi-agent architecture and more on putting agents into practical organizational processes.

LangGraph

LangGraph is aimed at developers who need more control over agent execution.

It provides primitives for building stateful, graph-based workflows where agents can interact, make decisions, maintain state, and hand work between different parts of the system.

For complex agent workflows, that level of control can be valuable.

OpenAI Agents SDK

The OpenAI Agents SDK provides building blocks for developers creating agent-based applications.

Agents can use tools, maintain context, and hand tasks to other agents. It's a good fit when you want to build the underlying agent experience yourself rather than adopt a complete collaboration environment.

The bigger question

These tools solve different parts of the same emerging problem.

Some focus on orchestration, some on agent frameworks, some on enterprise workflows, and others on human-agent collaboration.

Personally, I think the next interesting step is moving from:

Developer + AI assistant

to:

Team + multiple AI contributors

And that's where I'm particularly interested in what Sharkly.ai is trying to do: make the collaboration between humans and multiple agents part of the workflow itself.

For developers already experimenting with multi-agent development, what does your setup look like today?

What Changes When You Run Multiple Coding Agents in Parallel?

luc — Wed, 23 Sep 2026 12:49:41 +0000

Running one AI coding agent is fairly straightforward.

The interesting part starts when you have several agents working on different tasks at the same time.

One agent can handle a frontend issue, another can work on an API, while a third focuses on tests or documentation. The challenge quickly becomes coordination: knowing what each agent is doing, keeping tasks separated, and reviewing the results.

That’s the part I’ve been exploring with Sharkly.ai.

Instead of treating AI as a single coding assistant, the idea is to manage multiple agents as parallel contributors to the same project.

The workflow starts to feel less like “asking AI to write code” and more like managing a small team of AI developers.

For developers already using Claude Code, Codex, or other coding agents: what’s your current setup for running multiple agents in parallel?

What if multiple AI agents could collaborate on the same development project?

luc — Mon, 21 Sep 2026 06:48:07 +0000

Instead of relying on one agent for everything, developers could have specialized agents handling coding tasks, documentation, testing, or repetitive work while coordinating their progress.

Sharkly.ai brings AI agents into the same project workflow, where teams can assign tasks, track progress, and coordinate work between human teammates and AI agents.

The interesting challenge is making multiple agents collaborate without adding complexity to the developer workflow.

How are you experimenting with multi-agent development workflows?

https://sharkly.ai/

AI agents are becoming part of the development team.

luc — Fri, 18 Sep 2026 03:27:44 +0000

The interesting question is how we make them actually collaborate with developers.

With Sharkly.ai, an AI agent can be assigned tasks within a project, work on defined pieces of the workflow, and provide progress updates alongside human teammates.

Developers can focus on architecture, code quality, and decisions while agents handle repetitive or well-defined work.

Instead of AI as another tool, think AI as a teammate in the workflow.

How would you integrate an AI agent into your development team?

https://sharkly.ai/

How Humans and AI Agents Can Work Together

luc — Thu, 17 Sep 2026 09:49:17 +0000

AI agents are becoming part of the development workflow, but the real opportunity may be using them as teammates rather than standalone assistants.

With Sharkly.ai, developers can work with AI agents directly inside project workflows: assign tasks to agents, track progress, manage projects, and let agents handle repetitive work while humans focus on architecture, context, and decisions.

The goal isn’t to remove developers from the workflow — it’s to give them AI teammates that can contribute to the work.

How are you currently using AI agents in your development projects?

https://sharkly.ai/

When Does It Make Sense to Move Beyond Postman?

luc — Mon, 07 Sep 2026 11:23:46 +0000

Postman is still a great tool for testing APIs, but I’ve started wondering if an API client is enough for a modern development workflow.

As projects grow, we often need to:

Run API tests in CI/CD
Manage multiple environments
Keep API documentation in sync
Share test scenarios between developers and QA
Move from manual testing to repeatable workflows

That’s what led me to explore Apidog as a possible Postman alternative.

What I find interesting is that it combines API design, testing, documentation, mocking, and automation instead of treating them as separate workflows.

I know tools like Bruno, Insomnia, and Hoppscotch are also popular alternatives, so I’m curious what other developers here prefer.

Are you still using Postman, or have you moved to something else?

What If AI Agents Were Treated Like Real Teammates?

luc — Tue, 01 Sep 2026 09:11:35 +0000

AI agents are getting much better at executing tasks, but I think we're still using them like tools.

What happens if we start treating them more like actual teammates?

A human could assign a task, an AI agent could work on it, post updates, ask for clarification when blocked, and hand the result back for human review.

That requires more than an AI chatbot. You need shared context, task ownership, progress tracking, and clear human-agent handoffs.

I've been exploring this idea with Sharkly, a project management platform where AI agents can participate in the same workflow as human teammates.

https://sharkly.ai/

I'm curious how other developers are approaching this.

Would you rather have AI agents as assistants you interact with, or as actual members of your project team?

AI Agents Can Code. But Who Manages the Work?

luc — Thu, 27 Aug 2026 09:03:03 +0000

AI coding agents are getting surprisingly good at completing individual tasks.

But once you have multiple agents working on a real project, a new problem appears: coordination.

Who owns the task?
What is already being worked on?
What needs human review?
Where is an agent blocked?

I’ve been exploring Sharkly around this idea: treating AI agents as actual participants in the project workflow, alongside human teammates.

It feels like the next step after simply adding AI to development tools.

How are you currently managing work across multiple AI agents?

What Should an API Governance Tool Actually Check?

luc — Wed, 19 Aug 2026 06:29:01 +0000

API governance sounds straightforward until an organization has dozens or hundreds of APIs.

At that point, having a style guide isn't enough.

Someone needs to make sure APIs actually follow the rules.

I've been thinking about what an API governance tool should realistically check without turning governance into another bottleneck for developers.

For me, the useful checks fall into a few categories.

API Design Standards

The first layer is consistency.

For example:

Naming conventions
HTTP methods
Status codes
Pagination
Error formats
Versioning
Required OpenAPI fields

These are relatively easy to automate when the API contract is described with OpenAPI.

Security Checks

Governance should also catch obvious security problems before an API reaches production.

Things like:

Missing authentication
Weak authentication schemes
Exposed secrets
Insecure endpoints
Missing security requirements

Secret scanning seems particularly useful here because accidentally committing credentials is the kind of problem that should ideally be caught automatically.

Compliance

This is where governance becomes more organization-specific.

A company may have rules such as:

Every external endpoint must require authentication.

Or:

Every production API must include rate-limiting information.

Instead of relying on developers remembering these rules, an automated governance check can enforce them consistently.

Documentation Quality

An API can technically work while still being difficult to consume.

I'd like governance tooling to be able to detect things such as:

Missing endpoint descriptions
Missing parameter descriptions
Missing request examples
Missing response examples
Undocumented error responses

Documentation completeness seems like an underrated part of API governance.

Access Control

Governance isn't only about the API definition.

Once multiple teams are working together, organizations also need to control who can access, modify, publish, or administer APIs.

This is where things like RBAC, SSO, and user provisioning become relevant.

Auditability

Finally, there needs to be some way to answer:

Who changed what, and when?

Audit logs become increasingly important once APIs are shared across multiple teams.

Without them, investigating an unexpected API change can become surprisingly difficult.

So What Makes a Good API Governance Tool?

I don't think the answer is simply "more rules."

The best governance workflow should catch important problems early, ideally while developers are designing or reviewing an API rather than after deployment.

A useful workflow might look like:

API Design
↓
OpenAPI Validation
↓
Security Checks
↓
Compliance Checks
↓
Documentation Check
↓
Review
↓
Deployment

I've been looking at how platforms such as Apidog approach this by combining governance checks with the broader API development workflow, including RBAC, secret scanning, endpoint compliance, documentation completeness, and audit logs.

What I'm still wondering is how much governance should actually be automated.

For those managing APIs at scale, which governance checks have provided the most value?

And which checks ended up creating more friction than they were worth?