AI Workflow: The Year of Agents, 2026

It’s fair to describe Modash as an AI-first company. From engineering to marketing, to sales, everyone is using AI as a big part of their day-to-day workflow. So far this year, best practices on AI have changed multiple times – and it's only February. At Modash, we try our best to keep up! And today we will be discussing the evolution of our AI workflow in engineering, and where we're headed next.

AI Tools at Modash

Dictation tools speed up workflows and help us get our thoughts down on “paper.” Whether it's Wispr Flow or Superwhisper, everyone at the company uses a different flavor of AI-powered dictation tool. And they don't just write down what you said, but they fix up. They clean up all the pauses and format text into numbered lists or split into multiple paragraphs. If you misspeak and correct yourself, dictation tools also completely remove the misspoken word.

A fairly recent addition to our workflows in Notion AI. We made Notion our central hub for all our tools, connecting it to Slack, Linear, and for some, Gmail inboxes. You now can go to your Notion agent and ask a question about anything across all our tools. Sometimes the question can be as vague as "I remember talking to Silver about X", the agent will find the slack thread, find the corresponding ticket on linear, then give you a status update on the project.

On the engineering side, we adopted Cursor pretty much on-release. The direction the Cursor team chose seemed to us like the right bet for what the future of engineering would look like. As time went on, we became more and more convinced that the Cursor team understood what AI coding was going to look like: AI will write most of the code, the engineer is now the reviewer.

2025: Rules, Commands and BugBot

I remember the first time I got introduced to Cursor Rules, it was magical. To know that you can automatically enrich your prompt based on the context was a game changer. Rules allow developers to give extra instructions to LLMs automatically.

Initially, we mainly added rules for style guidelines. Slowly, we've started to add examples on how we specifically write tests in our code base, or patterns on how to do specific things around the code base.

When commands were introduced, all of our engineers started experimenting with having their own little commands locally. The ones that ended up landing in the shared command lists are /create-pr and  /code-review. We tried multiple tools for code reviews, but we ended up landing on Bugbot, which came with Coursera. It has access to all our rules already, so it made the reviewer agents aware of how things are done in our code base – and sometimes, even tag Cursor on Slack to ask it to make a quick fix.

This is when we started realizing that context is king: the models are only going to get smarter, we just have to help them with the tools. All of this has given us more predictable outputs when the AI is working on tasks. 

2026: Skills and Sub-agents

Although skills released in 2025; we just caught up to them. Skills are instructions that you can either manually pass to your LLM, just like you would a command, or the LLM can realize that it needs them and invoke them on its own. 

The simplest way to explain them is a mix between commands and rules. We have not migrated all of our rules into skills because some of them just don't make sense as skills, but all of our commands and reusable workflows are now written as skills instead of commands. Skills can also be just documentation for an external tool. The agent would know that you're mentioning the tool and reach for the skill to use it.

Another 2025 release we’ve caught up to is sub-agents. Sub-agents can have their own dedicated system prompt. This allows us to have agents that are specialized in certain areas of the code or have access to instructions to accomplish specific tasks. 

Another advantage of sub-agents is that they don't bloat the context of the main agent you're chatting with. The main agent can spawn multiple sub-agents that can run tasks without needlessly polluting the context of the main agent. They then report back to the main agent with a task done in a very short, concise report.

Chip and Dale

Chip and Dale is the cute nickname we give to our investigation or our bug investigation workflow. The workflow itself is effectively a skill that, once you run, will spawn multiple sub-agents to do the following:

• Collect context from Linear, Slack, and Notion: classify every piece as FACT or OPINION. Facts are system data, logs, errors, timestamps, DB records or code behavior. Opinions: human guesses like "maybe it's X", "I think Y caused this".  This phase results in what we call an investigation board that has all the gathered information.
• Hypothesis-testing loop:  We dispatch hypothesis sub-agents to investigate the potential issue based on the facts and opinions from the board. The categorization between fact and opinions can maybe guide the agent to the correct solution by following an opinion, but it will only use the fact when making decisions. This also updates the board with the investigation results.
• Reporting: The orchestrator agents then read the updated board and communicate to Linear/Slack. In this step, if the orchestrator agent feels that a verification is needed, it can still spawn more sub-agents to verify what's on the board.

Because this agent is constantly looking at the code base and gathering information, it would benefit from remembering its findings in future runs. We've come up with a system where the agent will suggest writing information that it deems important and hard to find in its memory. For now, all new entries to the memory need to be approved, but we are exploring a system where we're exploring ideas on how to make this fully automated.

Where We Are Now

We are not AI experts. There is no doubt that the LLMs today can reliably write code. As the model gets smarter, the best bet is to invest in the tools surrounding them and the ecosystem they’ll be used in. The limit is no longer "Can AI do this?" but "What can we do with AI?" It's no longer the models that are the limit, but it's our creativity and how to leverage these models.

Stay sharp!

‍