DEV Community: Louis Girifalco

Quote.Vote RC2: Phase 7 Is Ready for Parallel Contributors

Louis Girifalco — Wed, 09 Sep 2026 04:59:38 +0000

This week we announced Quote.Vote v2 RC2, another major milestone in the ongoing rebuild of our open-source platform.

For anyone new to the project, Quote.Vote is a text-first discussion platform built around a simple idea: instead of reacting only to an entire post, people can respond directly to the specific statements and passages inside it.

We open-sourced Quote.Vote last year, and since then a growing community of developers has been helping us rebuild the application on a modern technical foundation.

The goal of the v2 migration has never been to simply make the code newer. We want Quote.Vote to be easier to maintain, easier to test, easier for new developers to understand, and ultimately capable of being maintained by a community rather than depending on one person who knows every corner of the application.

RC2 is an important step toward that.

The frontend rebuild is now mature enough that our attention is increasingly shifting to the remaining backend migration. Over the last several weeks, our Lead Developer, Moti Rebuma, and I have reviewed the Phase 7 roadmap against the code that actually exists today, corrected outdated assumptions, mapped dependencies, and reorganized the remaining work into pieces that multiple developers can safely take on at the same time.

Moti has now completed his technical review, his final feedback has been incorporated into the GitHub issues, and the next phase is already moving.

So what are we actually migrating?

Quote.Vote has been evolving over the course of years, and like many long-running applications, that means parts of the system were built using different generations of technology.

The v2 frontend is built around Next.js and TypeScript, but parts of the backend still use our older Mongoose/MongoDB data-access patterns.

We have already adopted Prisma as the direction for the modernized backend.

So one of the major remaining Phase 7 goals is straightforward to describe even if the implementation is not:

Move the remaining backend database access from Mongoose to Prisma without changing how Quote.Vote behaves for users.

During our review, we discovered that the migration was actually farther along than the old roadmap suggested, as much of the GraphQL resolver layer is already written in TypeScript.

Several roadmap items still described the work as though we needed to convert large parts of the backend from JavaScript to TypeScript. That is no longer the primary challenge.

The main persistence migration is now:

Mongoose → Prisma

That discovery allowed us to simplify the roadmap substantially.

We reorganized the migration around the product

Originally, query migrations and mutation migrations were tracked separately. That made sense conceptually, but it made less sense when we thought deeply about the code.

Quote.Vote's GraphQL resolvers are generally organized around product domains, where the same files can contain several related operations. Asking one developer to migrate "queries" and another to migrate "mutations" could therefore send both developers into the same code.

Instead, the implementation work is now organized around the actual parts of Quote.Vote.

The new umbrella is:

#500 — Domain Resolver Prisma Migration

Under it, the migration has been divided into focused domains:

This is more than an organizational preference.

It means a contributor can understand one coherent part of Quote.Vote, migrate that area, preserve its behavior, update its tests, and submit a PR without needing to understand the entire backend first.

That is exactly the kind of development model we want for the project.

Establish the common pattern first

Before several developers start migrating resolvers simultaneously, we also need everyone working from the same underlying pattern.

That is the purpose of:

#153 — Integrate Apollo Server with Typed Context

In plain language, this establishes a consistent way for the GraphQL backend to access shared application services — including Prisma.

Rather than individual developers inventing their own way of creating or accessing the Prisma Client, the application will establish one predictable, typed context that resolvers can use.

For developers, that context will preserve things such as:

Prisma Client
authenticated user information
request and response access where necessary
pub/sub
request metadata
existing shared runtime dependencies

The important architectural rule is that Prisma Client should have an application-level lifecycle rather than being independently created inside individual resolvers or once per request.

That foundation is no longer theoretical. Shubham Kumar has already submitted PR #518, which implements the typed GraphQL context and shared Prisma Client pattern. The PR is now going through review before we adopt it as the canonical pattern for the domain migrations that follow.

Once that pattern is established and accepted, the domain migrations will have a common foundation to build on.

What is ready now?

Six Phase 7 domain migrations are currently marked Ready:

The first of these, Posts and Content, has already been assigned, giving us an opportunity to validate the shared Prisma/context pattern against a real domain migration once #153 is complete.

We also have several important pieces moving alongside the domain work.

#141 — Validate GraphQL Schema Generation — COMPLETED

This work has already landed.

PR #517 was merged on September 10, adding validation that the migrated backend can reliably construct and execute the GraphQL schema, including resolver bindings, custom scalars, introspection, queries, and mutations.

That gives the remaining migration work another automated guardrail as contributors begin working across the backend.

#147 — Restore Subscription Resolvers and WebSocket Runtime

Our audit showed that this is not simply a matter of translating an old subscription file into TypeScript.

The current backend needs the actual subscription/WebSocket runtime restored and integrated with the modern architecture.

#429 — Rename `Group` to `Tag`

This fixes some historical terminology.

What Quote.Vote calls a Tag in the current interface is still represented as Group in portions of the backend and GraphQL API.

Cleaning that up first prevents someone from spending time migrating backend terminology that we already know we want to replace.

The implementation will preserve the existing MongoDB records while renaming the concept at the application layer, avoiding an unnecessary database collection migration.

Some work is intentionally blocked

Another improvement to the roadmap is that we are being much more explicit about what should not be assigned yet. This is just as helpful as identifying what is ready.

The Groups/Domains/Collections Prisma migration waits for the Group → Tag work.

The legacy Roster/Buddy domain will now be retired rather than migrated directly to Prisma. The surviving responsibilities — including following, messaging, presence, and blocking — will remain in their appropriate domains rather than preserving an obsolete Roster abstraction. That work will become Ready once the shared context established by #153 lands.

The shared resolver utilities contain some of the heaviest remaining Mongoose usage, including reputation, scoring, Vote, and VoteLog logic. Those should move in coordination with the domains that rely on them.

Relationship resolvers should migrate after their corresponding parent domains become Prisma-backed.

And SolidConnection requires its own Prisma model and migration path before the associated Solid resolvers can leave Mongoose.

Our goal is to make safe parallel development possible.

The bigger change is the development model

This is the part of RC2 that I am probably most excited about.

A year ago, Quote.Vote becoming open source mostly meant that the repository was publicly available and people were welcome to contribute.

Today, something more substantial is starting to exist.

Developers are finding the project, taking issues, submitting pull requests, returning for additional work, identifying problems we missed, writing tests, reviewing each other's implementations, and helping us understand the architecture better.

Moti has increasingly taken on technical leadership around architecture, code review, integration, deployment, and helping contributors move their work forward.

Now other contributors can increasingly take ownership of clearly scoped implementation work.

We are beginning to see that model operate in practice. One contributor can establish a shared architectural pattern, another can review it from the perspective of the domain that will consume it, and our technical lead can validate the approach before it spreads across the rest of the migration.

My goal is becoming less about knowing how every piece of the application works and more about helping make sure the project has clear priorities, clear issues, and enough structure for other people to contribute successfully.

That is a much healthier place for an open-source project to be, so the roadmap itself aims to reflect that change.

A good issue should increasingly tell a developer:

Here is the problem.

Here is the relevant code.

Here is what must remain unchanged.

Here are the dependencies.

Here is how we know the migration is complete.

From there our mantra is to let developers build.

Want to take one?

If you have contributed to Quote.Vote before, this is an excellent time to jump back in.

If you are new to the project and comfortable with some combination of TypeScript, GraphQL, Apollo, Prisma, Node.js, or backend testing, there are now several bounded migration issues that should be much easier to approach than the old Phase 7 roadmap.

Take a look at the issues marked Ready, find something that matches the part of the stack you are interested in, and comment before beginning so we can coordinate assignments.

Start here

RC2 Beta:

https://beta.quote.vote

GitHub Repository:

https://github.com/QuoteVote/quotevote-next

Phase 7 Prisma Migration:

https://github.com/QuoteVote/quotevote-next/issues/500

There is still plenty of work between RC2 and the completion of the v2 migration. But we've reached an important point.

The schema validation guardrail has already landed. The shared Prisma/context foundation is under active review. The first domain migration has an owner. Other domains are ready for contributors. And the dependencies around the remaining work are becoming much clearer.

Most importantly, the development community around Quote.Vote is increasingly capable of moving that work forward together.

I want to thank all of the contributors who helped us get here.

The case for claim-level voting (and what breaks in current post voting systems)

Louis Girifalco — Sat, 04 Apr 2026 13:20:59 +0000

When I first started exploring claim-level discussion (highlighting individual sentences and voting on them), the idea felt abstract.

So I tried grounding it in real situations where existing tools struggle.

Here are three that keep coming up:

1. Policy & Civic Discussion

Problem:
Long proposals get reduced to binary support/opposition.

What breaks:
People agree with parts, disagree with others, but have no way to express that nuance.

What changes:
Each claim can be evaluated independently (agree/disagree, true/false), creating a map of where consensus actually exists.

2. Open Source RFCs & Design Docs

Problem:
Feedback lives in comment threads or PR discussions, hard to synthesize.

What breaks:
Important critiques get buried, and it’s unclear which ideas are broadly supported.

What changes:
Specific lines or claims can accumulate structured feedback, making it easier to see what holds up.

3. Research, Journalism, and Analysis

Problem:
Readers react to entire articles, not specific statements.

What breaks:
Claims that are contested or unsupported don’t get isolated clearly.

What changes:
Readers can attach agreement, disagreement, or evidence directly to individual statements.

What This Enables

Instead of:

ranking posts
arguing in threads

You get:

structured evaluation of ideas
visibility into agreement vs disagreement
a dataset tied to language itself

I’m building this as an open-source project called Quote.Vote.

If this resonates, I’d love your feedback:

Where do you see this working — or breaking?

What If Online Discussions Were Structured Around Claims Instead of Posts?

Louis Girifalco — Sun, 15 Mar 2026 02:18:45 +0000

Over the last few years I’ve been thinking a lot about a simple question:

Why do so many online discussions fail to produce clarity?

Most platforms structure conversation the same way:

someone writes a post
people reply in threads
the most visible comments rise through upvotes or engagement

This structure works well for visibility and participation.

But it often struggles with something else: collective reasoning.

A long thread can contain dozens of arguments, agreements, disagreements, and corrections. Yet the final result rarely becomes clearer over time. New readers must scan hundreds of comments to understand where people actually converge or disagree.

I began wondering whether the structure of discussion itself might be the limiting factor.

A Different Structure

One idea I’ve been exploring treats claims as first-class objects.

Instead of reacting to an entire post, participants interact with specific statements inside the discussion.

For example, a discussion might contain claims like:

"Algorithmic ranking reduces discourse quality."
"Chronological feeds encourage healthier conversation."
"Moderation transparency improves community trust."

Participants can then register:

agreement
disagreement
supporting commentary

directly on individual claims.

Over time the thread becomes a map of contested and convergent ideas, rather than a linear list of replies.

Why This Might Matter

Many communities depend on discussion quality:

open-source governance
moderation decisions
policy debates
community standards

Yet most of our discussion infrastructure evolved from simple comment systems.

It raises an interesting design question:

Could the structure of conversation itself influence the quality of collective decisions?

An Open Question

I’m currently experimenting with this concept in an open-source project and would love feedback from people who run communities or participate in governance discussions.

Some questions I’m exploring:

Does claim-level voting reduce conversational noise?
Does it help readers understand where agreement actually exists?
Does it fragment discussions too much?

If you’ve participated in large open-source communities or moderation systems, I would be very interested in hearing about your experience.

What mechanisms have helped your communities reach clearer decisions during difficult debates?

If you are curious about the experiment I’m building around this idea visit https://www.quote.vote/

Instead of reacting to entire posts, participants can agree, disagree, or add commentary directly on specific statements. Over time this will produce a visible map of where ideas converge and where they remain contested.

Quote.Vote is an open-source project, so anyone can setup their own environment. Help us explore whether structuring discussions around individual claims can improve the quality of online discourse.

If you’ve worked on governance systems, moderation tools, or large online communities, I would genuinely be interested in hearing what you think would work — or fail — in a system like this.

🎃 Quote.Vote Hacktoberfest 2025 — Building Civic Tech, One Pull Request at a Time

Louis Girifalco — Mon, 03 Nov 2025 06:05:02 +0000

October was an extraordinary month for Quote.Vote.

Hacktoberfest gave us the spark we needed to open the doors, welcoming contributors from around the world to help shape the future of a platform that treats communication itself as public infrastructure.

Our Hacktoberfest Roadmap board became a living snapshot of what collaboration looks like in motion. Every issue told a story. Some of features that shipped cleanly across the finish line, others of ambitious starts, half-built prototypes, deep reviews, and hard lessons learned.

Why People Chose Quote.Vote

When we asked contributors why they picked our project over thousands of others, the answer kept coming back to the mission.

“It felt like the work mattered.”

Quote.Vote treats conversation like civic infrastructure, not a commodity. No ads. No engagement algorithms. Just people, text, and respect. A chronological, transparent space for dialogue. That framing gave people a reason to care.

This was a resounding validation of our approach. I maintain Quote.Vote because I believe that improving how we communicate online is the first step necessary to solving the world’s biggest problems. This passion seems to have been found present in our contributors as well.

💡 Why Quote.Vote Exists

Our mission is to provide a platform for people to make their voice heard, and find consensus. We build tools that make respectful, evidence-based discussion easier, fairer, and more accessible. If we can elevate the quality of public dialogue, we can rebuild trust in institutions, reduce polarization, and make truth more discoverable.

Quote.Vote was born from frustration with how social media bends human dialogue toward outrage and profit. We asked a simple question... What if the internet were built for dialogue rather than sensationalism?

Our mission isn’t driven by growth hacking, or for ad revenue.
We’re building a space for public conversation the way you’d build a public library. Slowly, deliberately, and open for everyone.

Hacktoberfest was an invitation for the public to join our civic experiment, and it resonated with so many developers.

Every contributor who touched the codebase this month helped move us closer to a future where online conversation feels meaningful again and every name will be forever credited publicly for helping build this commons. We are so grateful.

⚙️ What We Worked On

This year’s Hacktoberfest wasn’t about hitting arbitrary numbers, we just wanted to get the codebase in the hands of the open source community. But what happened astounded us, as we ended up merging 31 pull requests!

We explored dark mode, geo-located quotes, and a rate-limiting system to protect the platform from spam.

We dove into SEO improvements, open graph metadata, and lazy loading to make Quote.Vote load faster and share better.

We revisited our mission page, improving accessibility and clarity of message.

We began modernizing the frontend with a Material-UI v7 upgrade, while refining internal structures for reputation scoring, search improvements, and invite-based onboarding.

Not every feature crossed the finish line — and that’s okay.

Some are still in review, some blocked, some parked for design iteration. But each conversation, pull request, and review strengthened the foundation we’re building on.

🧠 Lessons in Collaboration

As any maintainer knows, our most important effort is building the connective tissue that lets people work together. During Hacktoberfest, we learned that coordination is our greatest asset.

By the second week, as PRs piled up and feature branches multiplied, it became clear that coordination and mutual trust would matter more than commits. So we shifted focus from centralized velocity to cross-review.

Midway through the month, we reached out to the broader community for help reviewing code and cross-testing new features. That wave of support allowed us to clear our backlog, finalize merges, and finish strong. It proved that open collaboration when nurtured with clarity and trust scales better than any single contributor ever could.

The result was a team of contributors who had never met before working across time zones to support one another’s work. Through community outreach and open review threads, we found our rhythm and finished the month with a renewed sense of purpose and possibility.

❤️ Reflections and Gratitude

Hacktoberfest 2025 was a true milestone and turning point for our project.

This month proved that open-source software can be public service, that code reviews can be acts of empathy, and that even a comment on GitHub can move society toward greater understanding.

Most importantly, it demonstrated that open source can serve not only developers, but democracy itself.

To everyone who contributed, tested, debugged, or even asked a question, thank you!

The amazing developers who contributed:

OtavioXimarelli
DidiNDexter
olivermolina
CynthiaWahome
nur-hasin
Nayan-Kute21
gunjanghate
harshitaphadtare
TechnoBlogger14o3
Om7035
trickster026
motirebuma
Kaif-Imteyaz
Chitransh1011
JnsCas
shubham-01-star

Thank you!

Louis Girifalco
Founder, Quote.Vote

🌍 Quote.Vote — An Open-Source Public Square for Respectful Dialogue (Hacktoberfest 2025)

Louis Girifalco — Thu, 16 Oct 2025 04:27:00 +0000

Hello everyone 👋

This is my first Hacktoberfest as a maintainer, and I’m so excited to open the doors of Quote.Vote to contributors around the world. We’ve prepared a GitHub roadmap full of good first issues to make onboarding easy and approachable for developers of all experience levels.

Within the first day of posting in the official Hacktoberfest Discord, more than twenty contributors joined our roadmap.

The bottleneck we’re facing is code reviews. Our core developers are unavailable to provide their time as needed, which means we’re receiving great pull requests faster than we can review them.

If you’re an experienced developer who enjoys reading code, mentoring others, or improving collaboration workflows, we’d love your help reviewing PRs this month.

Timely feedback is vital for new contributors, and your support in reviewing code will directly help us maintain that rhythm and momentum.

👉 Join our community: discord.gg/3ycdHpJzE

Why Quote.Vote Exists

Quote.Vote was born from frustration with how today’s platforms warp dialogue through algorithms and ads. Many across the internet want an online space purely for respectful conversation, without anyone trying to capture attention for profit.

Growth hacking and monetization is not the priority, instead we focus on building civic infrastructure as if it were a public library. Every line of code adds up to one question: What if the internet were built for dialogue rather than sensationalism?

Hacktoberfest, for us, is about welcoming people into our civic experiment. Every contributor will be credited publicly on our site, and your name will be permanently associated with building a space that treats online conversation as a public good.

How It Works

The platform is radically simple: a quote, a response, a conversation thread. Think of it as a digital town hall where everyone can participate on equal footing.

Quote.Vote revolves around quotes as sparks for conversation rather than as weapons or out-of-context soundbites.

It’s a nonprofit project, building an open-source platform licensed under AGPL, ensuring it will always remain a public good.

No ads, no algorithms, just people, text, and respect.

Under the Hood

Quote.Vote runs on a React frontend, using a GraphQL API to communicate with a MongoDB backend.

The architecture is modular, so contributors can work independently without needing to understand the entire system on day one.

At its heart, Quote.Vote is built on the belief that dialogue itself is civic infrastructure.

We reject extractive models of platform building and treat stewardship—not ownership—as our guiding principle.

How to Contribute

If you’ve ever wanted your code to directly support democracy and dialogue, this is your chance.

Contributing to Quote.Vote means you’re shaping a piece of civic infrastructure. We welcome you, and Hacktoberfest is the perfect moment to make your first pull request.

Joining Quote.Vote during Hacktoberfest means joining a community that values humility, openness, and shared responsibility.

We’d love for you to join us this October and help shape what respectful online dialogue can look like.

👉 Quote.Vote Hacktoberfest Roadmap

github.com/orgs/QuoteVote/projects/1

🌍 Quote.Vote | An Open-Source Public Square for Respectful Dialogue (Hacktoberfest 2025)

Louis Girifalco — Thu, 02 Oct 2025 04:00:57 +0000

Hello everyone 👋

This Hacktoberfest, We’d like to introduce Quote.Vote the nonprofit, open-source platform for text-based dialogue. It’s designed as civic infrastructure to serve as a public square where people can quote, vote, respond, and deliberate respectfully with no ads and no algorithms.

⚙️ Tech Stack: React/Next.js frontend, GraphQL API, and a MongoDB backend. Made to be approachable for anyone familiar with modern JavaScript frameworks.

We’ve prepared a roadmap on GitHub with good first issues to make onboarding smooth for contributors of all levels. Whether you enjoy frontend, backend, or documentation, you’ll find clear entry points to get started.

👉 Quote.Vote Hacktoberfest Roadmap

🚀 How you can help:

Pick up a labeled issue from the Hacktoberfest roadmap
Open a PR — we’ll be reviewing daily throughout October
Get recognized on our public Contributors page

Thanks for checking us out, and happy Hacktoberfest!

Louis Girifalco
Founder, Quote.Vote

DEV Community: Louis Girifalco

Quote.Vote RC2: Phase 7 Is Ready for Parallel Contributors

So what are we actually migrating?

We reorganized the migration around the product

#500 — Domain Resolver Prisma Migration

Establish the common pattern first

#153 — Integrate Apollo Server with Typed Context

What is ready now?

#141 — Validate GraphQL Schema Generation — COMPLETED

#147 — Restore Subscription Resolvers and WebSocket Runtime

#429 — Rename Group to Tag

Some work is intentionally blocked

The bigger change is the development model

Want to take one?

Start here

The case for claim-level voting (and what breaks in current post voting systems)

1. Policy & Civic Discussion

2. Open Source RFCs & Design Docs

3. Research, Journalism, and Analysis

What This Enables

What If Online Discussions Were Structured Around Claims Instead of Posts?

Why do so many online discussions fail to produce clarity?

A Different Structure

Why This Might Matter

An Open Question

🎃 Quote.Vote Hacktoberfest 2025 — Building Civic Tech, One Pull Request at a Time

Why People Chose Quote.Vote

💡 Why Quote.Vote Exists

⚙️ What We Worked On

🧠 Lessons in Collaboration

❤️ Reflections and Gratitude

🌍 Quote.Vote — An Open-Source Public Square for Respectful Dialogue (Hacktoberfest 2025)

Why Quote.Vote Exists

How It Works

Under the Hood

How to Contribute

🌍 Quote.Vote | An Open-Source Public Square for Respectful Dialogue (Hacktoberfest 2025)

#429 — Rename `Group` to `Tag`