A few months ago, we thought we were building an assessment tool.
Pretty straightforward.
Students scan a QR code.
They submit writing.
AI reads it, scores it, gives feedback.
Teachers finally get something usable in real time.
It worked.
Teachers moved faster.
Students improved.
Data actually meant something.
That should’ve been the story.
Then we took on a completely unrelated project.
Different client.
Different domain.
Nothing to do with schools.
They didn’t want dashboards.
They didn’t want analytics.
They just wanted help answering a harder question:
“What should I do next?”
So we built something simple.
A short intake.
A few questions that force clarity.
And then… four specific moves.
Not advice.
Not options.
Just:
do this next.
That project isn’t even live yet.
But while we were building it… something felt familiar.
We started seeing the same pattern… everywhere.
A Head Start compliance system:
Staff log hours, track requirements…
and then hit the same wall:
“Am I actually doing the right thing next?”
So we added a layer.
Input → interpretation → next action.
Same pattern.
A financial tool:
Different stakes.
Same moment of hesitation.
“What’s the move?”
Same pattern.
Even a simple website product:
Someone fills out a form…
and what they really need isn’t a site.
It’s direction.
Same pattern.
At some point, it stops being a coincidence.
We went back to the classroom product—the one we started with.
And looked at it differently.
Not as grading.
Not as feedback.
But as a system answering the same question:
A student writes something messy.
A teacher looks at it and thinks:
“What do I actually do with this?”
That’s the moment.
Not the data.
Not the dashboard.
The decision.
Every system we had built—no matter the domain—was quietly solving the same problem:
Taking messy, real-world input…
and turning it into a clear next move.
Most software stops short.
It organizes.
It visualizes.
It suggests.
But it doesn’t decide.
So we changed how we think about what we’re building.
Not products.
Systems that:
take in messy input
compress it into something meaningful
generate a decision you can act on immediately
and then watch what happens next
In classrooms, that looks like:
Students write → we analyze → we recommend → teachers act → students improve
But if you run that loop enough times…
something shifts.
You stop just suggesting what to do.
You start seeing what actually works.
Not in theory.
In real classrooms.
With real students.
Under real conditions.
And eventually, you get to a different place:
Not
“here are some good options”
But:
“Given everything happening right now…
this is the move that will work.”
We didn’t plan to build that.
We kept building useful things…
and they all kept pointing back to the same idea.
So now we’re paying attention.
And increasingly, everything we build is starting from that same place:
What’s the next move… and how do we know it works?
