DEV Community

Cover image for How Non-Engineers Now Assign Work to Coding Agents
Emmanuel Mumba
Emmanuel Mumba

Posted on Edited on

How Non-Engineers Now Assign Work to Coding Agents

Until recently, coding agents were a developer tool. You opened a terminal, started Claude Code or Codex, and worked alongside it in your own repo. If you weren't an engineer, the closest you got was asking one to do it for you.

That's starting to change. Product managers, designers, support leads, and ops teams are now handing small pieces of engineering work straight to coding agents, and getting pull requests back for engineers to review.

This isn't a theory. epilot's engineering team shared their numbers: after giving non-engineers coding agents and access to the codebase, 11 non-engineers shipped 40 merged PRs in 60 days, from translations to UX fixes to small features.

In this article, I'll look at what changed, what non-engineers can realistically hand off, how it works in practice with Sharkly.ai, and where engineers still need to stay in the loop.

What Changed: Agents Moved Out of the Terminal

The agents themselves didn't suddenly become safe to hand to anyone. What changed is where the work happens.

When a coding agent lives in one developer's terminal, only that developer can give it work. Nobody else can see what it's doing, and there's no shared record of the request, the result, or the review.

When the agent sits on a shared task board, the picture looks different:

  • The request is a task, written in plain language, with screenshots and context attached
  • The agent is an assignee, like any teammate
  • The output is a pull request, linked back to the task
  • An engineer reviews it before anything is merged

That structure is what makes it safe for a non-engineer to start the work. They're not running code. They're writing a clear request and assigning it, and the normal engineering review still happens at the end.

What Non-Engineers Can Realistically Hand Off

Not everything belongs with an agent. The best candidates are small, clear, and easy to check. Here's how I'd think about it:

Good fit Needs an engineer first Keep with engineers
Copy and text changes Small features with clear specs Architecture decisions
Translations Bug fixes with a known cause Security and auth changes
UI tweaks to existing screens Config changes Database migrations
Tracking or analytics events New fields in existing forms Anything touching payments
Docs and help content Dependency updates Production incidents

This lines up with what epilot saw. Their non-engineers shipped work like 116 German translation improvements, customer portal config changes, analytics tracking, and small UX fixes, plus a few features such as auto-tagging for file uploads.

How It Works in Sharkly: Assign, Review, Ship

Sharkly is a shared workspace where people and AI coding agents work from the same task board. Its own description of Agents is "saved Agents you assign like teammates," which is exactly the model that makes this possible.

Here's what the flow looks like for a non-engineer.

1. An engineer sets things up once

Non-engineers don't configure agents. Someone technical does that once:

  • Creates the Agents the team will use, backed by coding tools such as Claude Code, Codex, Gemini CLI, or OpenCode
  • Gives each Agent its repositories, running on a Computer with the right credentials to clone the code
  • Connects GitHub, so pull requests link back to Tasks

After that, the agents are just names in the assignee list.

2. The request becomes a Task

A non-engineer can create the Task wherever they already work:

  • Directly in Sharkly, on the Space's board
  • From Slack, by @-mentioning the Space's Task assistant in a thread. It reads the conversation, writes up the request, and files a Task (see my Slack walkthrough for the full setup)
  • From Jira or GitHub, through Sharkly's sync, with an optional Triage step where incoming work "waits until someone decides"

Triage is worth using early on. It gives an engineer or PM a moment to check that a request is the right size before an agent picks it up.

3. Assign it to an agent

From the Task, the non-engineer picks an Agent or a Crew as the assignee, the same way they'd assign a person. The agent works in its own isolated worktree, so several tasks can run in parallel without stepping on each other.

4. A PR comes back, and an engineer reviews it

When the pull request includes the Task ID in its title, description, or branch name, Sharkly links it to the Task. The non-engineer can follow progress on the Task, and an engineer reviews the PR before it's merged.

The review step isn't optional, and that's the point. The non-engineer starts the work, the agent does the first draft, and an engineer decides what ships.

According to Sharkly's own guide, it's free for organizations of up to 5 people, and agents don't take up seats.

How to Write a Task an Agent Can Actually Do

The biggest skill for a non-engineer isn't coding. It's writing a clear task. A vague request gives a vague result, and someone has to clean it up.

Compare these two:

Fix the pricing page.
Enter fullscreen mode Exit fullscreen mode
On the pricing page, the "Annual" toggle shows monthly prices.

Expected: when Annual is selected, show the yearly price
(monthly price x 12, minus 20%).

Where: /pricing, the toggle above the three plan cards.

Screenshot attached.

Don't change the plan names, features list, or layout.
Enter fullscreen mode Exit fullscreen mode

The second one works because it covers five things:

  1. What's wrong, in one sentence
  2. What "done" looks like, specific enough to check
  3. Where it is, the page, screen, or file if you know it
  4. Evidence, like a screenshot or an example
  5. What not to touch, so the change stays small

If you can't write the "done" part, the task probably isn't ready for an agent yet. That's a good moment to loop in an engineer or PM.

Guardrails: Where Engineers Stay in the Loop

Opening up coding agents to the whole team only works with a few rules. These are the ones I'd put in place first:

  • Every change goes through a PR. No direct pushes to protected branches. epilot learned this the hard way when a non-engineer with push access bypassed CI and deployed to production. Nothing broke, but they tightened permissions right after.
  • Engineers review and merge. The agent's PR is a first draft, not a finished change. Reviews take real time, so plan for it.
  • Agents get limited access. Run them in sandboxes or on dedicated machines, with no production access and only the repositories they need.
  • Use triage for incoming requests. Let a PM or engineer check size and priority before an agent starts.
  • Respect the roadmap. If anyone can assign work to an agent, priorities can drift. Keep agent tasks on the same board as everything else, so the team can see what's being worked on.
  • Start with low-risk work. Copy, translations, and small UI fixes first. Expand once the team trusts the process.

Final Thoughts

Non-engineers assigning work to coding agents isn't about replacing engineers. It's about removing the queue in front of them.

The small fixes that sat in the backlog for weeks, like a typo, a translation, or a label that confuses customers, can now go from the person who noticed them to an agent, and then to an engineer for a quick review.

What makes it work is structure: clear tasks, a shared board, agents that act like assignees, and a review step nobody skips. That's the workflow Sharkly.ai is built around.

Start small. Pick one type of change, like copy fixes, let one non-engineer try it for two weeks, and see how many PRs actually get merged.

Top comments (1)

Collapse
 
kreout profile image
Andrei Ovcharenko • • Edited

One useful addition to the handoff is a small acceptance checklist tied to observable behavior: the trigger, the expected result, and one edge case. A PR can compile and pass CI while solving a different problem from the one requested. Asking the agent to show which check or example covers each criterion gives the engineer something concrete to review; green CI alone cannot establish that the task was understood.