This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

We are living through a time when AI-generated writing is becoming increasingly common, but much of it sounds remarkably similar.

When people use generic AI assistants to polish emails, academic papers, or technical reports, their original writing style can get replaced by repetitive buzzwords, predictable sentence structures, and a uniform corporate tone.

For students, researchers, professionals, and content creators, this creates a problem: their writing can lose the personal voice and natural rhythm that make it their own.

That's why I built InkFlow: The Adaptive Writing Twin & Anti-AI-Slop Engine.

InkFlow is an adaptive writing assistant designed to help people improve their writing while preserving their individual style.

It has four core capabilities:

• Personal Style Genome: Uses a two-minute linguistic calibration exercise to build an eight-dimensional profile of a user's writing style, including formality, sentence-length variation, vocabulary diversity, clause structure, and punctuation habits.
• AI-Slop Detection: Identifies common synthetic writing clichés and highlights phrases that make a draft sound generic.
• Four-Stage Rewrite Pipeline: Generates or transforms text, removes unwanted stylistic patterns, checks semantic consistency, and performs a light grammar pass designed to preserve the author's punctuation preferences.
• Adaptive Style Learning: Tracks writing changes across sessions and incorporates recurring stylistic preferences rather than overreacting to a single edit.

InkFlow is designed for university students, academics, non-native English professionals, content creators, and technical writers who want writing assistance without losing their own voice.

The Side Hustle: Monetization

InkFlow follows a freemium model.

Free Tier: Includes 1,500 words per day, one personal Style Genome profile, AI-slop highlighting, and access to the Humanize Studio.

Pro Tier — ₹39/month: Offers unlimited daily words, multiple writing profiles for different contexts, and priority access to higher-capacity open-weight models through an integrated Razorpay checkout supporting UPI, cards, and net banking.

The goal is to make personalized writing assistance affordable for students and independent creators.

Demo

Live Web Application: https://ink-flow-twin.vercel.app

Backend API: https://inkflow-backend-73hf.onrender.com

Demo Video:

hacktoberfest3rdchallenge.mp4 - Google Drive

drive.google.com

Here are some features you can explore:

• Humanize Studio: Paste a draft or raw bullet points, identify common AI-writing clichés, and refine the text with character-level punctuation differences.
• Two-Minute Voice Calibration: Complete four linguistic exercises to generate a personalized Style Genome.
• Sentence Cadence Analytics: Inspect sentence-length variation across paragraphs.
• Direct AI Writer: Draft emails and lecture notes, then refine them through the Humanize Studio.

Code

GitHub Repository: https://github.com/SoumyaGhosh2006/InkFlow

The project uses a modular full-stack architecture.

Backend: FastAPI, Python 3.11+, Motor for asynchronous MongoDB access, Groq inference, Pydantic v2, Razorpay integration, Sentry tracing, and Pytest.

Frontend: React 19, TypeScript, Vite, Tailwind CSS, Framer Motion, Zustand, Radix UI, Lucide icons, and Firebase Authentication.

The repository includes the implementation of the writing pipeline, style calibration, authentication, and subscription workflow.

How I Built It

1. Dual-Tier Open-Weight Inference

Rather than depending on a single model, InkFlow uses a primary model and a fallback model through Groq.

• Primary model: openai/gpt-oss-120b handles complex stylistic transformations, nuanced rewriting, and Style Genome conditioning.
• Fallback model: openai/gpt-oss-20b provides a lighter alternative when the primary model encounters timeouts, rate limits, or latency issues.

The backend uses FastAPI to coordinate requests from the React frontend and route them through the sequential rewriting pipeline.

2. The Eight-Dimensional Style Genome

A generic instruction such as "rewrite this in my tone" often produces an exaggerated imitation rather than a useful representation of someone's writing style.

InkFlow instead uses a short linguistic calibration exercise to capture different aspects of how a person writes.

The eight dimensions are:

• Formality: The balance between academic language and conversational expression.
• Syntactic Density: How frequently subordinate clauses appear in sentences.
• Lexical Entropy: Vocabulary diversity and variation.
• Burstiness Variance: Variation in sentence length, from short statements to longer, more complex sentences.
• Punctuation Signature: The author's use of em-dashes, semicolons, commas, and other punctuation.
• Clause Chaining: How the author connects related ideas.
• Contraction Ratio: The frequency of forms such as "don't" and "it's."
• Tone Affinity: Whether the writing tends to be assertive, exploratory, analytical, or pragmatic.

Together, these dimensions provide a more structured starting point for adapting the writing process to individual preferences.

3. The Four-Stage Sequential Rewrite Pipeline

InkFlow processes writing through four stages.

Stage 1 — Base Draft Generation: Expands raw bullet points or creates a first draft while preserving the original assertions.

Stage 2 — Style Transformation and Slop Removal: Applies the user's Style Genome and removes common synthetic clichés.

Stage 3 — Semantic Fidelity Check: Checks whether the transformed text retains the source's meaning and triggers a retry when significant semantic drift is detected.

Stage 4 — Quirk-Preserving Grammar Pass: Corrects errors while attempting to preserve characteristic punctuation choices and deliberate stylistic patterns.

The final result includes character-level differences so users can inspect the changes instead of blindly accepting a rewritten draft.

4. Engineering Challenges and Solutions

Challenge 1: Preserving Personal Punctuation

Conventional grammar correction can remove em-dashes, semicolons, and other punctuation habits that are part of someone's writing style.

InkFlow separates grammar correction into its own stage and uses deterministic checks to help protect those preferences.

Challenge 2: Preventing Semantic Drift

Aggressive cliché removal can accidentally remove important context, numbers, or factual claims.

InkFlow includes a semantic verification stage designed to detect meaningful divergence and retry when the rewritten text no longer adequately reflects the source.

Challenge 3: Improving the Mobile Writing Experience

A side-by-side editing layout can become difficult to use on smaller screens.

The mobile interface uses a segmented switcher between the source draft and the humanized result, a compact warning strip for detected phrases, and an automatic transition to the result after rewriting.

Challenge 4: Strengthening Authentication

During development, mock authentication tokens created the risk of visitors inheriting a test session instead of signing in with their own accounts.

The production implementation rejects mock tokens, removes frontend fallback tokens, uses Firebase browser-session persistence, and includes an inactivity-based logout policy. The application also allows users to explore drafting features while prompting them to sign in for protected operations.

5. Subscription and Reliability

InkFlow combines Firebase Authentication with a Razorpay-based subscription workflow. Its backend also includes Pydantic request validation, Sentry tracing, and automated tests.

The primary and fallback model arrangement is designed to improve resilience when the primary inference service experiences problems.

These components support the project's broader goal of making personalized writing assistance practical and affordable.

Why Does Open Innovation Matter?

Open innovation matters because writing is personal. People should have more control over how AI transforms their words instead of being forced into a single model's default writing style.

Greater control over writing style: Open-weight models give developers more flexibility to experiment with prompts, model selection, and style-conditioning techniques. This makes it possible to build a writing assistant around individual preferences rather than a generic corporate voice.

More flexible inference: InkFlow uses a primary and fallback model, helping the application respond to model availability and latency problems without relying entirely on one model configuration.

Affordable access: The project combines open-weight inference with a low-cost subscription model intended for students and independent creators.

A focus on authorship: The goal is not to replace a person's ideas with machine-generated prose. It is to help people express their existing ideas more clearly while retaining the characteristics that make their writing recognizable.

InkFlow is an exploration of how open-weight AI can support a more personalized writing experience.

My Agent Session

backend/app/services/pipeline.py

Created 4-stage sequential transformation pipeline with reason-aware semantic retry and punctuation protection gates.

backend/app/services/providers.py

Implemented dual-tier Groq LPU provider failover (120B primary -> 20B fallback) with granular connection timeouts.

$ pytest tests -q

39 passed, 0 failures. Verified provider failover, 4-stage retry gate, punctuation preservation, and quota resets.

backend/app/api/v1/payments.py

Configured Razorpay order creation and signature verification with default amount 3900 paise (₹39).

frontend/src/components/payments/UpgradeModal.tsx

Updated Pro subscription UI and checkout payload to ₹39/mo.

frontend/src/components/studio/TransformationStudio.tsx

Implemented responsive segmented view switcher (Source Draft vs Humanized Result) for mobile screens.

backend/app/core/security.py

Locked mock test tokens strictly to non-production environments with HTTP 401 enforcement.

frontend/src/components/auth/AuthModal.tsx

Created accessible AuthModal with Google authentication, value highlights, and activity gating.

frontend/src/lib/firebase.ts

Configured browserLocalPersistence, 1-week inactivity timeout limit, and throttled activity tracking.

$ npm run build && pytest tests -q

Frontend built in 2.37s with 0 errors. All 39 backend tests passed.

Direct Session Link: View full agentic session transcript on DEV

My First User

what my first customer said

reviewfromcustomer.mp4 - Google Drive

drive.google.com

Prize Categories

Based on the project description, these are the partner categories to consider. Include only those for which you can demonstrate the required integration.

• Best Use of Render: The FastAPI backend is deployed on Render.

• Best Use of Sentry Agent Tracing:

Team Submissions

@aishani_3009 was in my team, help me to develop this product.

My aim with InkFlow is to build writing assistance that adapts to people rather than making people adapt to AI.

Better writing should still sound like you.

Hacktoberfest #DEVChallenge #HF26Challenge #SideHustle #AI #OpenSource #WritingTools