Job-Giene: The Career OS That Turns AI Advice Into a Progress Loop

Career prep, but with memory

Most career tools stop at a useful output. Job-Giene keeps going. It stores profile state, gamification signals, resume data, and scoring history so each new action can build on the last one instead of replacing it.

That design choice is the real product thesis. XP, streaks, badges, and completed tasks are not decoration. They are the visible surface of a backend that treats career development as an accumulating state machine.

The part most AI apps skip: state

The codebase’s biggest clue is the data model. A User document carries far more than login data. It appears to hold XP, streaks, badges, profile fields, and completed tasks alongside authentication state. That means the product is designed around continuity, not isolated sessions.

Just as important, the repository keeps analytical records separate. Resume and ATSScore are modeled as distinct entities, which lets the app preserve raw resume content while tracking scoring over time. That separation matters because it makes trends visible without forcing every new insight to overwrite the old one.

How Gemini becomes a product feature instead of a text box

The technical center of gravity is cleanAndParseJSON. The function exists because LLMs are messy in predictable ways. They wrap JSON in markdown, add stray commentary, or return almost-correct fragments that break a UI if you trust them blindly.

Job-Giene responds with a defensive pipeline. It extracts the usable JSON, repairs common formatting issues, and only then hands the result to the rest of the app. That is a subtle but important product move: the frontend is never asked to interpret prose. It receives contracts.

function cleanAndParseJSON(raw: string) {
  const start = raw.indexOf('{');
  const end = raw.lastIndexOf('}');
  if (start === -1 || end === -1 || end <= start) return null;

  const candidate = raw.slice(start, end + 1)
    .replace(/```json|```/g, '')
    .trim();

  try {
    return JSON.parse(candidate);
  } catch {
    return null;
  }
}

Authentication that hints at a transition

The auth layer mixes JWT verification with a fallback x-user-email header. That reads like a product in transition. The system is clearly moving toward stricter sessions, but it still preserves a developer-friendly path for interim flows and admin checks.

The result is pragmatic, not elegant. It works because it balances security, convenience, and migration reality. In a young product, that often matters more than theoretical purity.

Why separate Resume from ATSScore?

This schema choice keeps the system honest. Resume content is the source material. ATSScore is the analysis of that material. By separating them, the app can show improvement over time without pretending the analysis is the same thing as the document itself.

That separation also creates room for iteration. If the scoring rubric changes, the app can update the analysis model without losing the original resume record. That is the kind of small architectural decision that makes dashboards, trends, and coaching possible later.

What this competes with

Job-Giene sits across several categories at once, but it does not fully belong to any of them. It is closer to a system that combines pieces competitors usually sell separately.

The differentiator is not feature count. It is the unit of value. Job-Giene treats progress over time as the primary product object, and everything else is there to support that.

The tradeoff: more coherence, more fragility

This architecture is strong because it is coherent. It is fragile because every layer has to behave. If the model output drifts, the parser has to catch it. If the auth model shifts, the fallback path has to stay safe. If the gamified state gets out of sync, the whole loop feels broken instead of helpful.

That is the cost of building a stateful AI product. You get memory, compounding progress, and richer UX. You also inherit a much harder consistency problem than a simple chatbot ever has to solve.