These posts will be some of our learnings as we build Fused with a goal of not having anyone write a single line of code anymore. We want to go towards everyone in the team being able to get their work done through agents.

It's been a crazy few months seeing the insane progress for how far agents have come, and keeping up with the latest is part of the work. We want to make it easier to keep up with the latest:

• Dedicated Slack channel only about ai-tips
• Standup has become less of a "what did I do today" and more of "here's what I learned about agents" today.
• Before starting new projects, asking Agents to do some research. There's only so much twitter / hacker news that you can keep up, asking AI if tools already exist has saved us from re-building things ourselves. Some of our favourite findings have been slash commands to help us through the day
  • /insights generates a HTML file of all your past conversations with Claude Code
  • /simplify makes your PRs simpler. Great when you've cracked a problem but think there's a simpler solution
  • /review to, well review a PR.
  • A whole host of plugins that's out there. We've found it well worth spending a bit of time exploring what's out there.

Some of the recent changes we've made in the last few weeks:

• Refactored our codebase to be more agentic-navigable. (more on this to come later)
• Taken a hard look at "what parts of the work are we redoing over and over again that could be automated better". This includes things like the release process of Fused: simplifying the release, having agents automatically spin up to generate release notes & update the relevant documentation
• Automating non technical parts of the work. Generating bug reports automatically from customer calls or while dog fooding, getting daily summaries of what's going on in the company, doing market research. There's so much more than just writing code, we keep learning new things every day.

What we've found out to be the most helpful:

• Keep trying bigger & bigger projects. The glass ceiling for what's possible with agents isn't obvious, we keep being surprised by how large of tasks agents can work on by themselves. It's tempting to see an agent fail at a task and think "ah well obviously AI sucks at <insert topic>". But models are getting better by the weeks, and we're all getting more used to writing tasks for AI. Anthropic recently announced dynamic workflows which only aims to push the task further and further out.
• A single agent doesn't have to do the whole work. Agents aren't all too good at reviewing their own work for example, especially as a conversation reaches its context limit. Using sub agents to review or using different tools like Cursor bot in Github serve as a second opinion.
• Thinking more like managers rather than individual contributors. We're changing our mentality away from "how do I implement the technical detail" to "what's the high level task here". We're spending more time writing specs, brainstorming on an implementation plan and less time working on the implementation details. Usually this requires doing a specific task with a lot of hands on, follow up prompts, back & forth but as more tasks get done, we gain confidence in the AI output & have better tests in place to catch mistakes.

What we stopped doing:

• "micro managing" skills. We started out by mapping every single project, way of working in a repo, telling agents where everything was and every design pattern. As models keep getting better, we noticed we got better results when we let the models do the thinking themselves and brainstorm together
• Trying to run too many instances at once. At first some of us started up to 10 or 12 agents but quickly realised that was not manageable. Instead, proper scoping of tasks, using auto mode and asking AI to check its own work & iterate until it's done has been more helpful to scale up the amount of parallel work.

Stay tuned for more of our learnings!

This is short #2 in the Road to Zero Coding series — short posts on getting towards building Fused 100% without writing a single line of code ourselves.

1. The problem with AI image generation at work​

We're a small team and we've been leaning on AI across the board — coding, reviewing customer feedback, writing docs. So we wanted to give image generation a shot for the blog post. Two problems showed up fast:

Inconsistent results. AI models hallucinate in unpredictable ways and require a lot of different prompt iterations to get right.

Hard to share across a team. I could create a repeatable pipeline in Claude or ChatGPT and share a .md file of my best prompts — but everyone on the team would still need their own setup to actually run it.

2. What we built​

We're always looking for ways to use Fused in our own daily work. We've built a platform that makes it easy to share pipelines and outputs — this was a perfect chance to test it.

So I built a Fused Canvas:

1. Pass a rough draft of an image (hand-drawn on an iPad)
2. Select a custom prompt for repeatable output
3. Run the pipeline using Nano Banana via OpenRouter, get the output on S3

Under the hood, it calls the OpenRouter API to run the image-to-image workflow:

@fused.cache
def call_api(model, full_prompt, api_key):
    response = requests.post(
        "https://openrouter.ai/api/v1/chat/completions",
        headers={"Authorization": f"Bearer {api_key}"},
        json={
            "model": model,
            "messages": [{"role": "user", "content": full_prompt}],
            "modalities": ["image", "text"],
        }
    )
    return response.json()

Starting from a hand-drawn sketch means the model has structure to work with — far fewer hallucinations, much more consistent composition.

Left: hand-drawn sketches. Right: output of the pipeline, directly used in the blog post.

3. Why this matters for a team​

Version controlled. The Canvas is pushed and pulled through GitHub. We can focus on iterating the prompts rather than chasing each other for the latest .md file.

Build once, available to everyone. I figure out which tool works best, build the pipeline once, and share it to the rest of the team — who don't need to worry about infrastructure or their own setup to use it.

I'm particularly excited about this because AI image generation can be flaky at best, a bit like code. Building pipelines that make it repeatable and easy to share means we get much more mileage from these models — beyond the "one time wow factor."

You can learn more about how we built this in this example in the Fused docs. We're since using this to generate visuals for docs pages too, and we want to keep exploring how to integrate more tools into repeatable pipelines.

This is short #1 in the Road to Zero Coding series — short posts on getting towards building Fused 100% without writing a single line of code ourselves.