Bring event instructions together in one workspace before participants see them.
Catch conflicting instructions and missing criteria, with source evidence behind each finding.
Exactly 180 seconds: one instruction accepts it, the other does not. Test the consequence of a small wording difference.
See the original passage behind a finding, highlighted in its source document.
Compare the original wording with a local correction. The organizer decides what changes.
Rerun to verify the fix. The duration issue resolves while the unrelated judging-criterion omission remains.
Take the evidence with you: export findings, revisions, and saved scenario results in one review report.

Inspiration

A small wording difference can create a big question for a participant.

“Your demo must be at most three minutes” and “Your demo must be under three minutes” sound almost identical. But a video that runs exactly three minutes satisfies one instruction and fails the other.

Hackathon instructions often live across an overview, official rules, submission guidelines, and FAQs. BriefCheck grew from a practical question: can we help organizers catch these differences before participants have to ask?

What it does

BriefCheck helps hackathon organizers review their instructions before publishing. It compares English event documents, surfaces conflicting requirements and missing information, and shows the exact passages behind each finding.

Organizers can paste instructions or import public webpages and text-based PDFs, then:

Compare video limits, team sizes, deadlines, judging criteria, and deliverables.
Test concrete scenarios, such as a demo lasting exactly 180 seconds.
Inspect source evidence and correct an extracted interpretation.
Accept, dismiss, or defer findings.
Edit a local draft, rerun the review, and see what changed.
Save private workspaces, collaborate through access roles, and export reports.

The organizer stays in control. BriefCheck does not decide which document has authority or automatically change published rules.

How we built it

We used the Devpost Learn Skill Pack to structure the scope, product requirements, and technical specification, then built with an AI coding assistant.

The frontend uses React and TypeScript. A Node.js backend handles imports, analysis, accounts, and exports, with SQLite for saved workspaces.

The analysis combines OpenAI structured extraction with deterministic checks. The model identifies requirements in English text, while application code compares supported requirements and evaluates scenarios. Every extracted quote must match its source before it can become evidence.

Documents and reviews are versioned, so correcting an instruction does not erase its history. Organizers can download JSON or printable HTML reports. An explicitly confirmed export can also publish a report to a configured GitHub repository.

Challenges we ran into

Finding a difference was only part of the problem. Explaining it accurately was harder.

A recommendation should not become a mandatory rule. An unsupported instruction should not quietly appear to have passed. A quote can be accurate while its interpretation is still wrong. These distinctions shaped both the analysis and the interface.

Keeping decisions consistent across edits was another challenge. Testing found cases where decisions on a new review were not saved correctly, stale collaborator data could overwrite newer changes, and an accepted finding could retain its approval after its interpretation changed. We fixed those issues and added regression coverage.

Accomplishments that we're proud of

The complete review-and-correction loop works.

In our browser test, BriefCheck found the difference between “at most three minutes” and “under three minutes.” At 180 seconds, it showed different outcomes. After aligning the wording and rerunning the review, the duration issue resolved while a separate missing judging criterion remained visible.

The build passed 26 automated unit tests, browser and API workflow checks, keyboard checks, and accessibility scans on the tested screens. We also verified live English OpenAI analysis and an actual GitHub report export.

A separate AI-agent review found additional problems that we fixed and retested. We preserved the original failures alongside the passing results to make the verification record transparent. This was AI-agent review, not independent human validation.

What we learned

A key lesson from the build was that useful AI review needs more than a convincing explanation.

It needs traceable evidence, explicit limits, and a way to test what an interpretation means. The 180-second example became a useful benchmark: a finding should help an organizer understand an actual consequence.

Testing also reinforced that a successful first review is not enough. Edits, reruns, saved decisions, and collaborator changes all need to remain consistent.

What's next for BriefCheck

The current release focuses on English instructions. The next step is to test it with organizers using real event documents and measure which findings are useful, which are distracting, and which requirements it misses.

We also want to expand coverage of conditional rules, compare results against a simple AI-prompt baseline, and make shared review easier to deploy.

The goal is straightforward: give organizers a dependable check before their instructions reach participants.