OPION

See every side of the story, trace the evidence, and judge for yourself.

Comment

Inspiration

I started Opion from a simple frustration. I could read several articles about the same event and still feel that I was seeing only part of it. One publisher would focus on the political response, another on the people affected, and a third on what was still uncertain.

News is biased by design. Even deciding which fact should come first changes how people understand a story. I didn’t build OPION to label publishers with a bias score or tell readers what to believe. I built it to place different reports side by side, show where they agree or conflict, and leave the final judgment to the reader.

Before Build Week, I independently built Perspectra, a backend for grouping reports about the same real-world event while keeping their original sources. The research behind it was also documented in a university thesis. Build Week gave me the reason to turn that backend idea into a product someone could actually hold in their hand.

That product is Opion.

What it does

Opion is a mobile-first news PWA with two main places: My Feed and Ask Opion.

My Feed presents one event at a time in an immersive mobile layout. A story is not treated as a single article. It is an event built from multiple reports, with a readable summary and access to the publishers behind it.

From any story, the reader can open Ask Opion without losing the event context. The investigation is organized into:

  • Quick Answer
  • Common Ground
  • Perspectives and Differences in Emphasis
  • Disputed Details
  • Uncertainty
  • Why It Matters
  • Expandable Source Evidence
  • Follow-up Questions

The citations are part of the answer, not decoration. Tapping a citation opens the matching evidence row, where the reader can see the publication, date, headline, excerpt, perspective label, and original article link.

For this MVP, I curated 18 real multi-source events from Perspectra. I removed flagged articles, kept the reachable source links, and packaged each event with the information Ask Opion needs. The demo is intentionally a stable snapshot instead of pretending that the full news pipeline is running live.

Opion also includes topic filters, saved stories, sharing, comments, reading preferences, Read Aloud controls, offline states, accessibility support, and installation as a PWA.

How we built it

From Perspectra to Opion

Perspectra uses the event as the main unit, rather than treating every article as a separate story. In simplified form, the system looks like this:

GLOBAL DISCOVERY

News sources
     |
     v
Ingestion and validation
     |
     v
Geographic and topic routing
     |
     v
Semantic clustering
     |
     v
Multi-signal event matching <----> Human review for uncertain matches
     |
     v
Event database with articles and provenance
     |
     +-----------------------------+
                                   |
ACTIVE ENRICHMENT                  |
                                   |
Thin or stale event               |
     |                             |
     v                             |
External discovery                |
     |                             |
     v                             |
Verify candidate against event    |
     |                             |
     v                             |
Attach article and rebuild -------+
     |
     v
MULTI-SOURCE ANALYSIS

Summary -> Claims -> Agreement -> Perspectives -> Opion

The important part is the relationship between an event and its contributing articles. If the articles are grouped incorrectly, every summary or perspective comparison built on top of them becomes unreliable.

Building the mobile PWA

I built the Build Week application with Next.js, React, TypeScript, Zustand, Vitest, and Playwright. Native scrolling and CSS scroll snap drive the feed. The app also has a web manifest and service worker for installation and offline behavior.

I kept the event data behind typed service contracts instead of importing it directly into the screens. That made it possible to connect the curated Perspectra snapshot without rebuilding the interface.

Ask Opion follows the same boundary:

Curated Perspectra event packet
              |
              v
Groq structures and explains the available evidence
              |
              v
Opion validates the structure and every source ID
              |
              v
The existing investigation interface renders the result

Groq runs only on the server through a Vercel function. It receives the selected event packet and must return Opion's fixed answer sections. It returns source IDs, not new links. If the response is malformed, misses a section, or cites a source outside the event, Opion rejects the whole response and shows an event-specific deterministic brief instead. The interface still works if the provider is unavailable or rate-limited.

Perspectra and the earlier Opion concepts existed before Build Week. The new mobile PWA, its feed, Ask Opion experience, structured Groq integration, fallback behavior, accessibility work, tests, and product polish are the Build Week work.

How I used Codex and GPT-5.6

I used GPT-5.6 through Codex throughout the project, starting with the product brainstorm and continuing through implementation, debugging, testing, documentation, and submission preparation.

Codex helped me turn a much larger idea into a Build Week scope I could finish. We worked through the mobile architecture, typed data boundaries, feed and investigation states, safe-area problems, keyboard behavior, source evidence, Groq validation, and automated tests. I repeatedly tested the real interface, shared screenshots, explained what felt wrong, and refined it.

I made the product decisions myself, including the OPIONname, the mobile PWA direction, the visual identity, the two-part navigation, the 18-event demo scope, and the decision to preserve uncertainty instead of generating a confident answer for everything. I also reviewed the generated code and kept the Git history as an honest record of the work.

GPT-5.6 was my development collaborator inside Codex. Groq has a different, smaller role: it is the optional runtime model that explains a selected event inside Ask Opion.

Challenges we ran into

The hardest backend problem was source recall. Perspectra's active-enrichment pipeline needs an external search provider to find more reporting for thin or stale events. The provider available to me had strict limits and cooldowns, and I did not have unrestricted paid search capacity. Many events therefore remained single-source and could not honestly enter multi-source analysis.

I chose not to hide that limitation. For the MVP, I reviewed the strongest multi-source events manually and curated 18 of them. I removed flagged items and preserved the genuine article metadata and links. The result is smaller than a live news service, but it is real and reproducible.

The next challenge was grounding Ask Opion. A fluent answer is not enough if the reader cannot see where it came from. I had to keep the attached event visible, connect statements to individual articles, reject fabricated source IDs, and make the original reports easy to open. The deterministic fallback also had to remain useful instead of becoming a generic error message.

Mobile layout caused a different set of problems. Browser controls, changing viewport heights, safe areas, the software keyboard, bottom navigation, sheets, and the audio player could all collide. Testing those states on mobile and fixing them took a large part of the polish work.

Accomplishments that we're proud of

I am proud that Opion feels like a product, not a dashboard placed on top of my research project.

  • A reader can move from a story to an investigation without losing its context.
  • The 18 demo events use real articles and reachable original-source links.
  • Ask Opion separates agreement, perspective, disputed details, and uncertainty instead of compressing everything into one confident paragraph.
  • Groq is restricted to the selected evidence, while the deterministic fallback keeps the demo reliable.
  • The PWA handles installation, offline behavior, mobile safe areas, the keyboard, reduced motion, and large text.
  • Automated unit and mobile end-to-end tests cover the core experience.

Most importantly, I finished it as a solo builder while keeping the boundary between my pre-existing Perspectra work and the new Build Week application clear.

What we learned

I learned that provenance cannot stay hidden in the backend. If users are expected to trust a multi-source answer, they need to see the sources at the moment a claim is made.

I also learned that uncertainty is useful product information. Saying what the available reporting cannot establish is often more honest than filling the gap with a smooth answer.

Working with Codex over the whole build was very different from using AI for a single code snippet. The useful part was the loop: build something, test it, look at the real screen, find what is wrong, and try again. I still needed to understand the code and make the final decisions.

Finally, I learned to protect the scope. Perspectra can grow into a much larger system, but a focused 18-event experience that works is more valuable for this demo than claiming live coverage I could not reliably provide.

What's next for OPION

The first priority is turning Opion into a production news application. That means continuous ingestion, better event matching, dependable active enrichment, stronger claim and perspective analysis, verified citations, and infrastructure that can run the full pipeline reliably.

After the news experience is mature, the same event-and-evidence approach could be useful for research papers, government reports, regulatory filings, and a small number of related video or audio sources. Those are later extensions. News remains the focus.

The mission stays the same:

See every side of the story, trace the evidence, and judge for yourself.

Built With

Share this project:

Updates