02 / PRISM

PRISM

My idea for a dedicated documentation application, shaped by a Copilot notebook workflow I'm already using and refining.

CONCEPT

Where the Idea Came From

PRISM grew out of something I'd been developing to make the documentation side of my job a bit easier.

It started when we were introduced to certain templates that had to be used when documenting technical support cases. I began experimenting with ChatGPT to help complete them, initially using a simple text file containing the templates and some rough instructions.

I'd provide my troubleshooting notes and ask ChatGPT to organise them into the required format. I also used it to help write customer emails, troubleshooting guides and other documentation.

When work introduced a policy requiring us to use Microsoft Copilot instead, I decided to take the opportunity to develop the approach further.

Rather than simply transferring my existing prompts across, I created a Copilot notebook with more detailed instructions, rules and reference material. I expanded the original templates to cover new case notes, case updates, failed contact emails and site visit requests, all following the formats required by the company.

I also added my customer troubleshooting guide. That means I can ask Copilot to write an email and include relevant troubleshooting steps from the guide, rather than having to provide those instructions separately every time.

Another addition was linking the notebook to our vulnerable customer training and procedures. If the information suggests that a customer may be vulnerable, or I identify them as such, the notebook is instructed to remind me of the appropriate process.

The interesting part is that I no longer need to write elaborate prompts for every task. The notebook already has instructions explaining its purpose, the available templates and the rules it should follow. I can concentrate on providing the information and specifying what I need.

I'm still refining the workflow and testing how reliably it behaves. I'd like to expand it to produce knowledge articles and more detailed technical guides, with the intention of eventually sharing it with the team.

Working through all of this gave me the idea for PRISM: what if the same approach could become a dedicated application, with the templates, instructions and supporting information managed through a purpose-built interface?

The standalone application is still a concept, but it's based on a workflow I've already been developing and using in practice.

How the Current Workflow Works

The Copilot notebook has gradually become more than somewhere to store a few prompts. I've been building it into a workspace that already understands what I'm trying to accomplish.

The notebook contains a set of instructions and rules explaining its purpose, the different types of documentation it can produce and the formats it needs to follow.

At the moment, I've configured four main templates: new case notes, case updates, failed contact emails and site visit requests. Each follows the format required by the company.

One of the more useful things I've configured is how the notebook handles troubleshooting information.

If I provide notes describing an investigation or troubleshooting I've carried out, the notebook is instructed to recognise that and produce three separate outputs:

  • New case note: A concise description of the problem originally reported, without mixing in all the subsequent troubleshooting.
  • Case update: A more detailed record of the investigation, including the checks performed, findings and actions taken.
  • Customer email: An appropriate update covering what was discussed, what's been completed and any further information or action required from the customer.

Rather than having to request and explain each document separately, I can provide my rough notes and let the notebook apply its existing instructions to produce the appropriate formats.

I've also included reference material that extends what it can help with. My troubleshooting guide provides steps that can be incorporated into customer emails, while the vulnerable customer training and procedures give it additional context for reminding me of the appropriate process when relevant.

What I particularly like about this approach is that I'm gradually moving away from writing individual prompts for every situation. The instructions, templates and supporting material are already there, so I can concentrate on the actual technical investigation.

There's still an important distinction between producing something that looks right and producing something that's accurate. I need to review the outputs, particularly when they involve technical instructions, customer communication or company procedures.

I'm continuing to refine the notebook and would eventually like to expand it to knowledge articles and more detailed troubleshooting guides.

Once I'm confident it behaves reliably enough, I'd also like to share it with the rest of the team. That would be an interesting test of whether the workflow is genuinely useful to other engineers, rather than just being something I've adapted to suit the way I work.

The PRISM Concept

The more I've developed the Copilot notebook, the more I've wondered whether the same approach could work as a standalone application.

At the moment, the workflow relies on Copilot, a notebook containing instructions and reference material, and templates I've configured around our company's documentation requirements. It works for what I'm doing, but it's also given me ideas about how the process could be made more flexible.

My idea for PRISM is to bring those different elements together into a dedicated application, with an interface designed around the workflow rather than relying on a general-purpose AI assistant.

Users could enter their notes, review the documents PRISM produces, make adjustments and choose what they want to copy or export. The underlying instructions, templates and reference material would already be configured, so using the application wouldn't require any knowledge of prompt engineering.

I'd also like to make those configurations customisable. Different organisations have their own documentation standards, terminology and procedures. Rather than building PRISM around one company's requirements, it could allow administrators or users to manage their own templates, rules and supporting material.

Another area I'd like to explore is running the AI locally. For organisations handling customer information or other sensitive data, having greater control over where that information is processed could be a useful advantage. There would still be security, accuracy and compliance considerations to work through, but it's something I'd like to investigate.

I'd initially focus development on technical support and IT documentation, partly because that's where the idea originated and where I have practical experience of the problems it's intended to solve.

However, I don't think the underlying approach needs to be restricted to IT. The same principles of interpreting information, applying rules and producing structured documentation could potentially be adapted for other roles and industries without fundamentally changing the application.

The aim wouldn't be to remove people from the process. I'd want users to review and edit the generated documents before using them, particularly where accuracy, customer communication or company procedures are involved.

PRISM is still a concept rather than a developed application. The Copilot notebook gives me a practical starting point, but turning that experience into a reliable, configurable application that other people can use would be a project in its own right.

How I'd Approach Building It

Although I've got quite a few ideas for PRISM, I wouldn't want to start by trying to build everything at once.

The first step would be a relatively simple prototype focused on IT support documentation. That's the area I know best, and I've already got experience of using the underlying workflow through my Copilot notebook.

I'd start with a straightforward interface where I could enter rough troubleshooting notes and have PRISM generate a set of structured documents. The initial outputs would probably be a new case note, a case update and a customer email, with the ability to review and edit each one before copying or exporting it.

One of the first things I'd need to work out is how to manage the instructions and templates. I wouldn't want them buried throughout the application code. Ideally, they'd be stored separately so they could be edited, replaced or expanded without having to rebuild the whole application.

I'd also want to experiment with how the AI uses reference material. My Copilot notebook has shown me the value of providing instructions and supporting documents in advance, but a standalone application would need a reliable way of selecting and applying the relevant information.

Choosing the AI model would be another important part of the project. I'm particularly interested in exploring local models, but I'd need to establish whether they can produce sufficiently accurate and consistent results, especially when following detailed formatting instructions.

I'd be happy to experiment with different models and approaches rather than committing to one immediately. The goal would be to find something that works reliably, not simply to use a particular technology because it sounds interesting.

I'd initially develop and test PRISM using fictional support scenarios and example templates, rather than real customer information or internal company documentation.

Once the basic workflow was working, I could start introducing more advanced features, such as configurable templates, additional document types, reference libraries and potentially different organisational profiles.

I think the important thing would be to prove that the application can do the core job well before making it more complicated.

Testing the Idea

One of the things I'd want to establish early on is whether PRISM actually offers an improvement over the workflow I'm already using.

My Copilot notebook gives me a useful starting point because I've already spent time developing instructions, templates and reference material around real documentation requirements. That means I'd have something to compare a prototype against, rather than building an application without knowing what a successful result should look like.

I'd start by creating a collection of fictional IT support scenarios, ranging from straightforward incidents to more complicated investigations involving several troubleshooting steps, findings and follow-up actions.

I'd then use those scenarios to test whether PRISM can consistently produce the right documentation, follow the configured templates and distinguish between the original reported problem and the work carried out afterwards.

Accuracy would be particularly important. I'd want to check that it doesn't invent troubleshooting steps, claim that actions were completed when they weren't, or introduce information that wasn't present in the original notes or supporting material.

I'd also test how reliably it follows instructions. For example, whether it uses the appropriate reference material when requested, handles missing information sensibly and continues producing consistent results when the same information is written in different ways.

Beyond the generated documents, I'd want to evaluate the application itself. Is it easier to configure and use than a Copilot notebook? Can someone unfamiliar with the underlying prompts understand what to do? Does it actually reduce repetitive work, or have I just moved the complexity somewhere else?

I'd be interested in comparing different AI models too, particularly to understand whether a locally hosted model could deliver acceptable results without needing unnecessarily powerful hardware.

Eventually, I'd like to get feedback from other people using fictional scenarios and example templates. Something that works well for me might be confusing or frustrating for someone approaching it for the first time.

I think that would be the real test of PRISM: not just whether I can make it generate convincing documents, but whether it can do so accurately, consistently and in a way that's genuinely useful.

What's Next?

For now, I think the best place to continue developing the idea is with my existing Copilot notebook.

I've already put quite a bit of work into the instructions, templates and reference material, but I want to make sure it behaves consistently before taking things further.

My next priority is refining the workflow, testing it against different situations and expanding its capabilities to include knowledge articles and more detailed troubleshooting guides.

Once I'm happy with how reliably it works, I'd like to share it with colleagues and see how they get on with it. That should be particularly useful because they'll approach it differently from me. They might find problems I haven't encountered, suggest improvements or identify other ways it could help.

I'd also like to understand whether it genuinely makes documentation easier for other engineers, rather than simply producing nicely formatted text.

A lot of what I'm learning should be transferable to PRISM. The instructions, template structures, reference material and rules for interpreting information could all help inform how a standalone application eventually works.

I'm not in a particular hurry to start building PRISM itself. I'd rather continue improving something I'm already using, learn from the results and use that experience to make better decisions about the application.

If the notebook proves useful beyond my own workflow, that would be a good indication that the underlying idea is worth developing further.