AI discovery and implementation scope
In short
In shortSplash Creative implements AI in four stages: map the task step by step, agree on examples of right and wrong output, run a focused pilot on real data, then decide whether to put it into production. Each pilot is judged on output quality, usefulness, running cost, and how it fails. The outcome can be a production system, a simpler automation, an existing product, or a decision to stop.
- Who it is for
- Teams with a repeated task, bottleneck, or information problem they want to examine
- What it covers
- Workflow discovery, a focused pilot scope, evaluation criteria, and planning for what comes next
- Who does the work
- A senior team led by David Herskowitz, Founder and Creative Director
- How it is priced
- Scoped to the business need; scope, timing, and fee agreed in a proposal before kickoff
Our view
Most AI projects start with a tool and go looking for a problem. The demo works on clean examples, then meets real inputs: a scanned PDF, a vague email, a customer who asks two things at once. AI is good at a lot, but it's confidently wrong often enough that you need to know when it's wrong before your customers do.
What we do instead
We start with the task, not the model. We write down what correct output looks like before anything is built, and use those examples to judge every version. We decide in advance what the system can do on its own, what needs a person's approval, and what it should do when it isn't sure.
Where we've done it
Our site assistant is scoped to one job, helping visitors find work and shape a brief, and draws only on information we've defined. Both are built the way we build for clients: a narrow task, clear boundaries, a person in the loop.
What we look at before anything ships
- 01
The task, step by step
We break the workflow into its steps, inputs, and handoffs before choosing a model. Often only part of it suits AI, and the rest is better handled by a simple rule, an integration, or a person.
- 02
A test set of real examples
Agreed examples of right and wrong answers, drawn from your actual work. They're how we judge quality now and catch regressions later, when a prompt or a model changes.
- 03
The information it draws on
Results are only as good as the documents and data the system can reach, and whether they're current and permitted for this use. We review sources, access, and retention before recommending an approach.
- 04
Where a person reviews
Which actions run on their own, which need sign-off, and what happens on low confidence. Those boundaries are written into the pilot scope, not discovered in production.
- 05
Failure cases and logging
Confident wrong answers, missing context, and inputs outside the expected range are the failures we plan for. Logging lets the people responsible see when the system needs attention.
- 06
Cost and adoption
A pilot also measures what it costs to run and whether the team actually uses it. A tool nobody opens isn't saving anyone time.
This method suits you if...
- You've tried an AI tool that looked great in a demo and fell apart on your real inputs.
- The task involves decisions where a wrong answer costs money, trust, or a client.
- Your information is spread across documents, inboxes, and systems that don't talk to each other.
- You need to show a partner, board, or client why the system can be trusted.
- You want a clear yes or no from a pilot, not a pilot that quietly becomes production.
- You'd accept hearing that a simpler automation or an existing product is the better answer.
Not a fit
If you want AI added everywhere at once, or a system that acts without anyone ever checking it, this isn't our approach. We'd rather ship one task that holds up than ten that need babysitting.
How we take a task from idea to production
- 01
Map the task
We document the steps, inputs, handoffs, and judgment calls in the current process. You get a clear view of which parts suit AI and which don't.
- 02
Define good output
Together we collect real examples and mark what right and wrong look like. Nothing gets built until we've agreed on how it will be judged.
- 03
Run the pilot
A narrow version runs on real inputs alongside the people doing the work today. We track quality, usefulness, running cost, and every failure.
- 04
Decide with evidence
We review the results with you against the measures agreed at the start. The next step might be production, a simpler automation, an existing product, or stopping, and we'll recommend whichever the evidence supports.
- 05
Build for the people who run it
For production we add the integrations, access permissions, monitoring, and logging the system needs. The team responsible gets documentation and training, so they can tell when it needs attention.
Discovery, pilot, or production system?
Each stage has different requirements. We scope them around a specific use case and agree on what would justify further investment.
Discovery
- What it establishes
- Whether AI suits the task and what good output looks like
- What it involves
- Mapping the process and the points that need human judgment
- What it leads to
- A specific use case with evaluation criteria
Pilot
- What it establishes
- Output quality, usefulness, operating cost, and failure cases
- What it involves
- A defined task, data access, integrations, boundaries, and measures of success
- What it leads to
- A decision on production, a simpler automation, an existing product, or a pause
Production system
- What it establishes
- A system the responsible team can run and check
- What it involves
- Integrations, access permissions, evaluation, logging, and handoff
- What it leads to
- Defined points where the system acts and where someone reviews it
Questions, answered.
What is an AI pilot?
A focused test of one task on real inputs, with the data access, boundaries, and success measures agreed in advance. It answers one question: does this output justify going further?
What if the pilot shows AI isn't the answer?
Then the pilot did its job. We'll tell you plainly and recommend what would work better, whether that's a simpler automation, an existing product, or a clearer process.
How do you measure whether the output is good?
Against a set of real examples we agree on before building. We check accuracy and usefulness on those cases, look at how it fails, and re-run the same set whenever prompts or models change.
Which AI models do you use?
Whatever fits the task. We work with Claude, GPT, Gemini, and open models, chosen for accuracy, speed, cost, and where your data needs to live. We're not tied to any vendor.
How long does a pilot take?
It depends on the task and how quickly we can get access to real data and tools. We put the timeline in the proposal, and a pilot is kept deliberately narrow so you get an answer quickly.
How is the work priced?
Mapping, a pilot, and a production system are scoped separately, because each one needs different work. Data access, integrations, evaluation, and ongoing running all affect the fee, which is agreed in a written proposal before kickoff. Share a budget and we'll tell you which stage it fits.
