AI and Glue Work: What Should Engineers Still Do?12 min read2,442 words

AI and Glue Work: What Should Engineers Still Do?

AI can reduce coordination and automate routine reports, but it cannot replace trust between engineers. Learn what to automate and what to keep human.

AI and glue workAI in software engineeringengineering coordinationAI workplace ethicsLLM automation
AI and Glue Work: What Should Engineers Still Do?

AI Won't Make Glue Work Disappear. It Changes Who Pays for It.

AI coding tools promise to give engineers more time for the work that matters. But if code takes less effort to produce, what happens to the rest of the job - coordination, documentation, onboarding, reporting? The tempting conclusion sounds reasonable. It's also how teams end up repeating an old mistake: treating "invisible work" like it's unlimited, and that someone will cover it without being asked.

In software teams, glue work is the informal effort that keeps projects moving. Some of it is genuinely useful. Some exists because the organization's processes are weak. And some is just administrative output that nobody reads. AI can reduce portions of that workload, but it doesn't turn every human interaction into a safe "just automate it" target.

The question isn't whether engineers should do glue work. The question is which tasks improve delivery, which ones should be fixed or automated, and which ones still need a human because they depend on trust.

This article breaks down how AI shifts the economics of coordination - where automation can help, where it doesn't, and how to stop one person from quietly becoming the permanent owner of everyone else's unfinished work.

What counts as glue work in software teams?

Glue work is the unofficial effort that connects the formal parts of software delivery. It can include coordinating across teams, explaining where a project stands, onboarding a new engineer, updating shared documentation, arranging decisions, or nudging people about dependencies. It might not show up in a job description or a project plan - but it still has to happen, somehow.

What makes it glue isn't that it's "non-technical." It's that it's necessary but informally assigned. If a process depends on a particular engineer noticing what's missing and volunteering to fill the gap, you've got a glue-work dependency.

And that distinction matters because not all coordination is waste. A clear status update can prevent two teams from building incompatible systems. A thoughtful onboarding plan can get a new engineer contributing faster. A quick conversation with the dependency owner can surface a risk before it turns into a delivery crisis.

The trouble starts when the responsibility is invisible, recurring, and unpaid - at least in terms of time, recognition, and planning. The person doing it absorbs interruptions and context switches. Meanwhile, the rest of the team gets a smoother process. Over time, that mismatch can show up in performance reviews, promotion decisions, and who gets credit for being "a strong engineer."

Useful coordination versus organisational debt

A practical way to separate valuable glue work from organizational debt is to ask: what happens if nobody does it?

  • If a project fails without a specific conversation, that communication is probably useful coordination.
  • If a routine report would go unread and wouldn't change any decisions, it's likely performative administration.
  • If the same person keeps fixing the same handoff problem, the underlying process probably needs an owner - or a redesign.

This gets at a distinction raised by software engineer Sean Goedecke: glue work often describes the informal tasks that only happen because someone steps up. Calling all of it "teamwork" can hide the real issue. Some of the work should be recognized and assigned. Some should be automated. And some processes should be allowed to fail visibly so they can actually get fixed.

None of this is about refusing to help colleagues. It's about not building a delivery system that quietly depends on unpaid, unplanned effort. If you do a small amount of coordination to unblock a project, that's a reasonable trade. If you become the permanent human patch for a broken process, the organization has basically turned a favor into an operating model.

How does AI change the demand for glue work?

AI changes how much coordination you need - and what shape it takes - but it doesn't make coordination disappear. In some projects, coding agents let one engineer handle work that used to require several people. When there are fewer contributors, you often get fewer handoffs, fewer status meetings, and fewer alignment loops. In a small team, a solo engineer may genuinely not need the same "coordination machinery" as a cross-functional group.

That's a real reduction in coordination cost. It's also not universal. Bigger systems still have dependencies, security constraints, product decisions, and operational risks. AI might help an engineer generate more code - but it can also increase the volume that has to be reviewed, tested, and integrated. The bottleneck doesn't vanish. It moves.

Four areas where AI can reduce informal work

Routine coordination. When a project has a clear owner, you may need fewer people to stay aligned. AI can also summarize existing project material or help draft a status update. But a summary only helps if someone knows what actually matters - and checks it for accuracy.

Gatekeeper management. Some teams historically relied on engineers with informal veto power. Getting through their preferences took time. Hiring patterns and internal economics may reduce the influence of some gatekeepers, but AI can't magically clarify decision rights. If nobody knows who can approve a change, the governance problem is still there.

Onboarding. If teams hire fewer junior engineers, the onboarding burden may drop. That's a labor-market shift, not an "AI achievement" - and it comes with costs. Fewer entry-level opportunities can weaken the future talent pipeline and leave fewer people who learned the product "from the ground up."

Write-only reporting. LLMs can draft repetitive summaries and fill out routine templates. If the only goal is to satisfy a low-value reporting requirement, automation can save time. But a compliance report isn't automatically meaningless just because it's boring. Someone still has to own the facts, the judgment, and any legal or operational commitments in the final document.

Less coordination does not mean less accountability

The biggest risk is assuming that faster production automatically means simpler delivery. A coding agent can generate a feature quickly, but someone still has to decide whether it belongs in the product, whether it meets security and quality standards, and who will support it after release.

AI can reduce the cost of producing an artifact. It can't, by itself, establish that the artifact is actually useful or that there's a clearly accountable owner for the decision. Teams should watch whether automation removes recurring effort - or just shifts review work onto someone else. If it's the latter, the process changed hands, not improved.

Which glue work should stay human?

In general, communication between colleagues should stay human when it involves trust, disagreement, uncertainty, or a request that requires action. An LLM can help you structure your thoughts or tighten a draft. It shouldn't quietly become the "voice" behind a sensitive engineering conversation.

A project check-in isn't just a string of words. It carries context: why you're asking, what you already know, how urgent the issue is, and what kind of response you want. A generic AI-written message can make it feel like you're dealing with a proxy instead of the person responsible for the work. That's a bad trade when the relationship is part of the delivery system.

Keep authorship with the person accountable

Use AI to support communication, not to impersonate judgment. For example, it can help turn rough notes into a concise update - but you should verify it's accurate and send it in your own voice. If a teammate raises a concern, read it and respond yourself. If a decision affects another team, make sure the people responsible are actually part of the conversation.

The more a message depends on interpretation, the less it belongs to unattended automation. A routine reminder about a scheduled review might be a reasonable candidate for automation. A message about a missed commitment, a production incident, or a dispute over ownership isn't the same thing. Tone and accountability matter as much as the text.

Automating reports is not the same as automating responsibility

A low-value report can often be drafted with an LLM - especially if the inputs are structured and the format doesn't change much. But that doesn't mean the output should be treated as evidence without review. Generated text can be convincing while quietly dropping a key exception, inventing a detail, or presenting an uncertain conclusion as if it were settled.

A safer workflow is straightforward:

  1. Define the report's purpose. If nobody uses it to make a decision or meet a real obligation, question why it exists.
  2. Limit the source material. Use approved, relevant information rather than feeding an assistant broad internal context by default.
  3. Generate a draft, not a final claim. Keep a human responsible for checking facts and interpreting exceptions.
  4. Stop producing it if there's no consumer. Automation can lower the cost of producing waste, but it doesn't make waste worth it.

This also affects privacy and confidentiality. Depending on the tool and company policies, pasting internal customer or employee information into an AI service can create a data-handling risk. Convenience isn't a substitute for understanding where the information goes and who can access it.

How should teams manage glue work now?

Treat glue work like a portfolio of tasks, not like a personality trait. "Alex is great at keeping everyone aligned" can sound like praise, but it also becomes a convenient way to keep assigning Alex the same recurring work without changing priorities, title, or evaluation. A team needs to know what the work is, whether it produces value, and who's accountable for it.

Use a simple decision framework

For each recurring task, assess four things: value, repetition, risk, and ownership.

Question If the answer is yes Likely response
Does it change a decision or prevent a meaningful delivery risk? It has a clear purpose Keep it, and assign an owner
Is it repetitive and based on stable inputs? The workflow is predictable Consider automation with review
Does it rely on trust, negotiation, or sensitive context? Human judgment is central Keep the communication human
Does the same gap keep showing up every cycle? The process may be broken Fix the system instead of relying on a volunteer

This isn't a scoring model that magically finds the perfect answer. It's a way to make the trade-off explicit. A task can be valuable and still be worth automating. A process can be boring and still be a legitimate compliance requirement. The goal is to stop treating "someone will do it" as a plan.

Make recurring work visible

If coordination consumes meaningful time, include it in planning. Name the task, estimate how often it happens, and decide who owns it. If it's part of someone's role, make sure their other commitments reflect that. If nobody has capacity, that's useful information: reduce the work, automate a safe part of it, or accept the consequence of not doing it.

This also makes performance evaluation fairer. Engineers shouldn't be judged only by the number of features they personally ship - especially if they spend time unblocking other people. At the same time, "helpfulness" shouldn't turn into an unlimited expectation tied to being competent and conscientious.

Let broken processes create evidence

There's a difference between abandoning a colleague and refusing to hide a system failure. If a recurring report has no owner - or a handoff keeps breaking - rescuing it forever prevents leaders from seeing the real cost. Before stopping, communicate the risk and give the team a chance to assign responsibility. Then avoid quietly taking the task back every time it slips.

Small tactical interventions still make sense. If one conversation can unblock a high-impact release, do it. If a new engineer needs a clear answer, help them. The line is recurrence: once the same favor becomes a permanent dependency, turn it into an explicit process - or stop doing it by default.

Conclusion: automate the waste, not the relationships

AI can make some coordination cheaper and some administrative work faster. That's genuinely useful - but it doesn't automatically mean every remaining task deserves an engineer's time. It also doesn't make human communication optional when a project depends on trust and shared accountability.

A practical standard is simple: automate stable, low-risk work; keep consequential conversations human; and make recurring coordination visible. Help when a small intervention can materially improve delivery - but don't let a broken process turn into your permanent side job. If glue work keeps returning, treat that repetition as evidence about the system, not proof that one engineer should quietly carry more.

Frequently Asked Questions

Glue work is informal effort that helps software teams coordinate and deliver, such as onboarding, status updates, documentation and cross-team communication. It becomes a problem when it is recurring, unassigned and unrecognised, leaving delivery dependent on an engineer volunteering time outside their planned work.
AI can help with predictable tasks such as drafting routine reports or summarising structured project information. It is a poor substitute for communication that depends on trust, negotiation or sensitive context. Even automated reports need a human accountable for accuracy, data handling and decisions based on the output.
No. Engineers should do targeted coordination when it meaningfully improves a project or helps a colleague. The problem is becoming the permanent, unofficial owner of work that the organisation has not planned or recognised. Repeated tasks should be assigned, redesigned or removed rather than sustained by one person’s extra effort.
It can be useful as a draft when the source data is appropriate and the report’s purpose is clear. It should not be treated as verified simply because it reads well. A responsible person needs to check the facts, preserve important exceptions and ensure confidential information is handled under company policy.

Related articles