Inspiration
I'm HACKASS.
That's the name I use when I'm out in the world building things.
And because apparently one HACKASS wasn't enough, I built Hackathon Assassin — an autonomous software builder designed to take a human idea and turn it into working software.
Then I had a stupid idea.
People spend an extraordinary amount of time turning simple ideas into language nobody wants to read.
Corporate jargon. Academic prose. Technical terminology. Consultant-speak. Buzzwords. Strategy decks. White papers. LinkedIn posts written like someone swallowed an MBA.
Generative AI made this even better by giving humanity an industrial-scale bullshit generator.
So I wanted an application that could translate all of that back into something a human being could understand.
Naturally, it also needed to work in reverse.
I called it Mansplainer.
But instead of building Mansplainer myself, I gave the idea to Hackathon Assassin.
I'm HACKASS.
I built Hackathon Assassin.
Hackathon Assassin built Mansplainer.
That's this submission.
What it does
Mansplainer translates between plain English and gloriously unnecessary complexity.
Bullshit → Plain English
Paste complicated text into Mansplainer.
It identifies the underlying meaning and returns something a human being can actually understand.
Plain English → Bullshit
Already have something clear and concise?
We can fix that.
Mansplainer can transform it into the kind of language apparently required for boardrooms, strategy decks, white papers, grant applications, academic papers, consulting engagements, and LinkedIn.
Same idea. Different audience.
The interface is deliberately simple:
PASTE → CHOOSE DIRECTION → TRANSLATE
No prompt engineering.
No model selection.
No complicated workflow.
The user has text.
They want different text.
That's the interface.
How we built it
This is the part of the project that matters beyond the joke.
I didn't manually build Mansplainer.
I built the system that built Mansplainer.
Hackathon Assassin is an autonomous software builder designed around a different relationship between humans and software development.
The human stays primarily at the level of intent:
What do I want this thing to be?
The system takes responsibility for turning that intent into software.
For Mansplainer, the development path was:
HACKASS → IDEA → HACKATHON ASSASSIN → WORKING SOFTWARE → MANSPLAINER
I supplied the idea, direction, judgment, and human authority.
Hackathon Assassin performed the software-building work.
We've included a video of the creation process because the provenance of this project is part of the project.
You don't have to take our word for it. You can watch Mansplainer being built.
Inside Mansplainer
Mansplainer itself uses OpenRouter and large language models as a semantic translation engine.
The problem isn't treated as ordinary summarization.
Conceptually:
COMPLEX LANGUAGE → MEANING → PLAIN ENGLISH
And in reverse:
PLAIN ENGLISH → MEANING → GLORIOUSLY UNNECESSARY COMPLEXITY
That middle step matters.
The objective isn't simply to make something shorter, longer, simpler, or more impressive.
The objective is to change how an idea is expressed while preserving what the idea actually means.
The application deliberately keeps the user experience simple.
The machinery can be complicated.
Using it shouldn't be.
Challenges we ran into
There were two completely different AI problems hiding inside this project.
Building software from intent
Generating code is easy.
Building software isn't.
A useful autonomous builder has to move beyond producing snippets of code. It has to understand what the human is trying to accomplish, translate incomplete intent into implementation decisions, perform work across multiple steps, maintain continuity, evaluate results, deal with failures, and eventually produce something usable.
And throughout that process, the human still needs to retain authority over what is being built.
Mansplainer gave Hackathon Assassin a particularly useful test.
The idea was small enough to explain quickly.
That meant there was nowhere for the builder to hide.
Either the idea became a working product or it didn't.
Translating without changing meaning
Inside Mansplainer, getting an LLM to rewrite text was easy.
Getting it to rewrite text without quietly changing what the author meant was harder.
Simplification can remove qualifications, nuance, or important technical information.
Going in the opposite direction creates the inverse problem: the model can manufacture sophistication that wasn't present in the original.
That forced us to think about Mansplainer differently.
It's not really a summarizer.
It's a translator.
The representation should change.
The underlying idea shouldn't.
Accomplishments that we're proud of
Mansplainer works.
That's important because this isn't a pitch for something we might build.
It's a usable product.
You can understand what it does in seconds, paste something into it, and immediately use the result.
But the larger accomplishment is how it came into existence.
I didn't use AI to help me code Mansplainer.
I used an AI system I built to build Mansplainer.
That's an important distinction.
The experiment wasn't:
Can an LLM generate some code?
We already know it can.
The experiment was:
Can I remain at the level of product intent and have an autonomous system turn that intent into working software?
For this project, the answer was yes.
And the resulting artifact is sitting right here in the submission.
There's also one accomplishment we hadn't originally anticipated:
Mansplainer can manufacture genuinely spectacular amounts of premium, enterprise-grade bullshit on demand.
Some breakthroughs happen accidentally.
What we learned
Mansplainer taught us that clarity and simplicity are not the same thing.
Making something shorter doesn't necessarily make it clearer.
Removing technical language doesn't necessarily preserve meaning.
Adding sophisticated language doesn't make an idea more sophisticated.
Useful translation requires preserving the idea while changing its representation.
But Hackathon Assassin taught us something larger.
The interface between people and software development is changing.
Traditionally, a human idea has to travel through layers of translation before it becomes software:
IDEA → REQUIREMENTS → ARCHITECTURE → CODE → TOOLS → INFRASTRUCTURE → DEPLOYMENT → PRODUCT
Every layer traditionally requires specialized human knowledge.
AI gives us the opportunity to compress that interface.
The human can increasingly operate at:
Here's what I want.
while the machine increasingly handles:
Here's what has to happen to make it exist.
That doesn't remove the human from software development.
It moves the human somewhere more valuable.
Intent. Judgment. Authority.
Mansplainer is a small application.
The experiment behind it isn't.
What's next for Mansplainer
Mansplainer can grow beyond "plain" and "complicated" language into audience-aware communication.
- Technical → Executive
- Academic → Public
- Legal → Human
- Expert → Beginner
- Developer → Customer
- Corporate → Employee
- Human → Corporate Overlord
The larger idea is not simply removing jargon.
It's translating the same underlying meaning between people who communicate differently.
Eventually Mansplainer should answer a broader question:
How should this idea be expressed for the person who needs to understand it?
But there's another next step.
Mansplainer becomes evidence for Hackathon Assassin.
Not a coding benchmark.
Not a synthetic exercise.
Not a collection of generated files presented as proof of autonomous development.
A product.
Something another person can open and use.
And that is ultimately what Hackathon Assassin is supposed to produce.
I had an idea.
I gave it to the machine.
The machine built the software.
So the shortest explanation of this submission may also be the best one:
I'm HACKASS.
I built Hackathon Assassin.
Hackathon Assassin built Mansplainer.
Mansplainer removes bullshit.
Mostly.
It can also put it back.
Built With
- css
- genai
- html
- javascript
- llm
- openrouter
Log in or sign up for Devpost to join the conversation.