# Julian Garcia: AI Engineer & Fullstack Software Engineer

> AI Engineer and Fullstack Software Engineer building production LLM products with React, Next.js, Java and Node.js.

Last updated: 2026-10-21. Canonical source: https://www.jandresgarcia.dev/

## Summary

Julian Garcia (Julian Andres Garcia Mosquera) is an AI Engineer and Fullstack Software Engineer based in Medellín, Colombia, with 4+ years of professional experience. He builds production-ready AI products (LLM integrations, RAG, vector databases, multi-model orchestration) on top of solid fullstack foundations in React, Next.js, TypeScript, Java, Spring Boot, Node.js, Kafka and microservices. He currently works as a Software Engineer at ChenMed and builds two AI products end to end: EApply (eapply.jandresgarcia.dev), a multi-model LLM pipeline that tailors CVs to job posts without inventing experience, and Clara, a personal finance AI agent where a deterministic engine owns every number. Both run on JAG HQ, his self-hosted platform with a keyboard-first Backstage control center, self-hosted CI and an agent workflow driven by Plane tickets and SDDs. He also publishes Agentville (agentville.jandresgarcia.dev), a free, open-source Claude Code desktop mod that draws every Claude Code session as a pixel-art office where you approve, answer and message all of them from one desk.

## Key facts

- Full name: Julian Andres Garcia Mosquera
- Also known as: Julian Garcia, JAndresGarcia (GitHub)
- Role: AI Engineer & Fullstack Software Engineer
- Experience: 4+ years as a professional software engineer
- Location: Medellín, Antioquia, Colombia
- Languages: English, Spanish
- Email: dressg7@gmail.com
- LinkedIn: https://www.linkedin.com/in/jgarciamosquera/
- GitHub: https://github.com/JAndresGarcia
- CV (PDF): https://www.jandresgarcia.dev/julian-garcia-cv.pdf

## Areas of expertise

- AI Engineering
- Large Language Models (LLMs)
- Retrieval-Augmented Generation (RAG)
- Vector Databases
- Prompt Engineering
- Multi-model LLM orchestration
- GenAI security
- AI observability
- LLM cost engineering
- Claude
- System Design
- Fullstack Web Development
- React
- Next.js
- TypeScript
- Node.js
- Java
- Spring Boot
- Microservices
- Apache Kafka
- GraphQL
- MongoDB
- Redis
- Docker
- Kubernetes

## Work experience

### Software Engineer, ChenMed (2023 - Present)

- Designed and optimized internal applications used by doctors to provide health services to seniors across the USA.
- Reduced system load times by over 30% through architecture refactoring, enhancing patient care workflows and driving operational efficiency.
- Specialized in implementing microservices to ensure system reliability and creating seamless user experiences utilizing React.
- Collaborated closely with cross-functional teams to deliver high-quality, scalable solutions.

Technologies: Java, Kafka, MongoDB, GraphQL, Docker, Kubernetes, Microservices, React.js, TypeScript, DataDog, CI/CD, ArgoCD, CQRS, DGS

### Senior Frontend Developer, Void.gg (2022 - 2024)

- Led the development of key features for an enterprise-level microservice application, ensuring scalability and efficiency.
- Specialized in building and maintaining high-performance user interfaces using NextJS.
- Actively participated in code reviews to guarantee code quality and maintainability across the frontend ecosystem.
- Collaborated closely with designers, product managers, and fellow developers to define and deliver innovative solutions.

Technologies: NextJS, TypeScript, MongoDB, Mantine, AWS S3, Redux ToolKit (RTK), TailwindCSS

### Full Stack Developer, Kurius Chocolate (2021 - 2022)

- Led the design of a dynamic e-commerce application using Figma, co-leading its development and maintenance with ReactJS.
- Deployed MVPs via Netlify and integrated Stripe to implement a highly secure, seamless payment gateway.
- Built a scalable, non-relational database architecture utilizing MongoDB to support efficient data management.

Technologies: ReactJS, Flux, Stripe, Python, MySQL

### Software Engineer, Mantum SAS (2020 - 2021)

- Developed user interfaces aligned with Figma design guidelines, deploying new application features employing TypeScript and Next.js.
- Ensured clean, maintainable, and scalable component architecture to guarantee an enhanced, recruiter-ready user experience.

Technologies: Figma, NextJS, Php, NodeJS

## Projects

### EApply (Closed beta)

AI platform that tailors a CV to a job post with a multi-model LLM pipeline, scores ATS fit before and after with a deterministic engine, and renders a new PDF, without inventing experience.

Case study: https://www.jandresgarcia.dev/projects/eapply/
Live app: https://eapply.jandresgarcia.dev

How a run works:

1. You paste a job post and drop in a CV.
2. The API validates the input, checks credits, queues the job and opens a live SSE stream.
3. A separate worker process picks the job up from the queue.
4. Extraction, with a vision model for scanned PDFs. Every model call goes through the router, rate limits and a daily budget.
5. A fast model extracts the job skills, and each one is graded by how much proof the CV has.
6. The quality model rewrites the CV using only proven skills.
7. The output validator rejects any lost skill or unsupported claim. A regression triggers the fallback.
8. The score you see is computed by a deterministic engine, never trusted from the model.
9. Typst renders the new PDF, and the run is stored.
10. Each stage streamed to the browser live, about 40 seconds end to end. Judge models then grade the result in the background.

Components:

- Web app (Next.js 16 · React 19): Upload, live progress, results and history. Streams every pipeline status over SSE, with replay if the connection drops.
- API (Fastify · SSE): Validates the PDF and job post, checks credits, queues the job and opens the live stream.
- Job queue (BullMQ · Redis): Separate worker processes with a dead-letter queue, plus queues for quality reports, exports and reminders.
- Cost & rate limits (Daily budget · TPM/RPM): Admission control per model with priority lanes and 429 cooldowns. A daily AI budget stops spend before it runs away.
- Parse (Text + vision OCR): Hybrid extraction: text first, a vision model as OCR fallback for scanned CVs, then an LLM builds a canonical CV.
- Skill evidence (Graded by proof): An LLM extracts the job skills; each one is graded strong, attenuated or excluded by how much proof the CV really has.
- LLM rewrite (Rewrites, invents nothing): The quality model rewrites the CV using only proven skills. Structured output escalates from the fast to the quality tier on repair.
- Output validator (Honesty · skill preservation): Deterministic checks reject lost skills and unsupported claims before anything is scored. A regression over 5 points triggers the fallback and refunds the credit.
- Scoring engine (Deterministic ATS score): The model proposes a score, but the number shown comes from a deterministic scoring engine, plus the honest ceiling.
- Model router (Fast · Quality · Vision · Judge): Each step asks for a tier, not a model. The writer provider is swappable by config without touching the pipeline.
- Quality judges (LLM-as-judge · claim check): Async lenses score each result (recruiter scan, ATS, interview odds) and an entailment check verifies every claim. Nightly evals in CI.
- Skill embeddings (Vector skill matching) [planned, not built yet]: Next wave: local embeddings to match skills by meaning instead of by name. Planned, not built yet.
- Render service (FastAPI · Typst): A Python microservice turns the result into a PDF in one of five templates.
- Postgres · S3 (Runs · history · files): Postgres via Drizzle for runs, credits and the job tracker; S3-compatible storage with signed download tokens.
- Observability (OpenTelemetry): Traces with tokens and cost on every model call, plus structured logs and budget alerts.

Technologies: Next.js, Fastify, Postgres, BullMQ, Redis, LLMs, Multi-model routing, Typst, OpenTelemetry

### Clara (In daily use · private app)

Personal finance AI agent where a deterministic engine owns every number: the model works through typed tools, a validator blocks unverified figures, and a deterministic router picks between three model tiers under a daily spend cap.

Case study: https://www.jandresgarcia.dev/projects/clara/

How a run works:

1. You ask: how much can I still spend until the end of the month?
2. The API checks the session and passes the message on.
3. A deterministic router classifies it: this is chat, so it goes to the strong model.
4. The AI agent starts a tool loop. The call is logged against the daily spend cap.
5. It calls a calculation tool instead of doing the math itself.
6. The finance engine computes the exact number from real data.
7. Before anything is shown, every figure in the answer is checked against the tool results. Unverified numbers are blocked.
8. You get the answer, with a link to see how it was calculated.

Components:

- PWA (Installable · passkeys): A static Next.js export served by the API, installed on the phone and unlocked with Face ID.
- iOS Shortcuts (Automatic purchase ingest): Card payments arrive through Shortcuts to an ingest-only endpoint with its own token.
- API (Fastify · one container): One Docker image on an ARM64 server, reachable only inside a private tailnet.
- Scheduler (06:30 agent tick · FX feed): A daily agent tick planned by the server, the exchange rate every 30 minutes, backups and a weekly digest.
- Intent router (Picks a tier, no LLM): Deterministic rules decide which model tier handles each request. A purchase over 25% of monthly income escalates.
- AI agent (Tool loop · capped): Understands the request and explains the result. Works through tools in a loop with an iteration cap; writes come with undo.
- Tools (Read · calculate · act): Typed tools for reading data, running simulations and taking actions. The model never touches the database directly.
- Finance engine (Owns every number): Balances, projections, budgets and the health score, computed in integer minor units. No model does arithmetic.
- Figure validator (Blocks unverified numbers): Any figure in the answer that does not exist in a tool result is blocked before it reaches the screen.
- Model tiers (Fast · Strong · Frontier): Routine work goes to a fast model, chat to a strong one, monthly reviews and big decisions to a frontier model. Each role has a fallback provider.
- Spend guard (Every call logged · daily cap): Every call is logged with its cost. A per-run guard and a daily cap switch the AI off on their own, with an alert at 70%.
- Evals (60 live cases · CI gate): A hermetic suite plus a live eval against real models. The first live run scored 31/60 while the hermetic one passed; server-side guards closed the gap.
- SQLite (WAL · nightly backups): The single source of truth, with WAL checkpoints every 15 minutes and a backup every night.
- Exchange rate (datos.gov.co): The official COP/USD rate feeds income projections in both currencies.
- Semantic memory (Long-term recall) [planned, not built yet]: Next: a semantic memory layer so the agent can recall past decisions. Planned, not built yet.

Technologies: Next.js PWA, Fastify, SQLite, Drizzle, Zod, AI agents, Tool calling, Multi-model routing, Docker

### JAG HQ (Private · tailnet only)

Self-hosted platform that runs every product on one ARM server behind Tailscale: a keyboard-first Backstage control center, self-hosted GitHub Actions runners, a single deploy entrypoint with rollback, live Docker logs, host health checks, Plane for tickets and an agent workflow built on skills, SDDs and per-agent worktrees.

Case study: https://www.jandresgarcia.dev/projects/jag-hq/

How a run works:

1. A change starts as a Plane ticket, moved to In Progress the moment work starts.
2. An agent picks it up in its own worktree, following the repo's skills, SDD and house rules.
3. It opens a pull request with the ticket key in the title.
4. CI runs on self-hosted arm64 runners on the same server.
5. Merge only on green CI. The merge triggers jag-deploy, the only way into production.
6. It rebuilds and restarts only the affected product, with a rollback ready.
7. Public traffic reaches EApply through the tunnel; everything else stays inside the tailnet.
8. The deploy, host health and live logs show up on the wall, and the ticket moves to Done.

Components:

- Owner devices (On the tailnet): Laptop and phone join the private tailnet over WireGuard. That is the only way into the server.
- Visitors (Public internet): Public users only ever reach EApply, the one public product.
- GitHub (Repos · PRs · Actions): Private repos for the platform, the control center and each product. Every PR carries its ticket key.
- Tailscale (Private tailnet): SSH and every private panel are reachable only inside the tailnet; the host firewall drops everything else.
- Cloudflare (DNS · Tunnel): DNS and a Cloudflare Tunnel publish EApply without opening an inbound port on the server.
- Caddy (TLS · host routing): One reverse proxy terminates TLS and routes each hostname to its service, with tailnet-only rules for private panels.
- Plane (HQ · EAPP · CLARA tickets): Self-hosted project tracking. Ticket state moves in real time: In Progress on start, the PR linked on open, Done after merge and verification.
- Agent workflow (Skills · SDD · worktrees): Skills, SDDs, handoffs and house rules versioned in the repo, so any agent can pick up a ticket cold. One git worktree per agent.
- CI runners (Self-hosted · arm64): GitHub Actions runners live on the same server: native arm64 builds at no cost, with CPU and memory capped so a build never degrades production.
- jag-deploy (Only path to prod · rollback): A single root-owned entrypoint deploys or rolls back one target at a time. Nothing reaches production by hand.
- Backstage HQ (Control center · ⌘K): Seven keyboard-driven windows: the wall, projects, host health, live logs, docs with architecture, project conformance and the tools inventory.
- EApply (Public product): Frontend, API, workers and a render service as their own Compose project, published through the tunnel.
- Clara (Tailnet only): A single container with its own SQLite, reachable only from the owner's devices.
- Host health (Checks every 5 min): Disk, containers, runners, memory, load and certificates checked every 5 minutes, plus uptime monitors and alerts.
- Own data (Postgres · MinIO · Redis): Databases and object storage run on the same host, no managed services.
- Backups (restic · daily): Daily restic backups to Oracle Object Storage.
- Central secrets (SOPS · age) [planned, not built yet]: Next: encrypted secrets in the repo with SOPS and age. Planned, not built yet.

Technologies: Backstage, Docker Compose, Caddy, Tailscale, Cloudflare Tunnel, Plane, GitHub Actions, Uptime Kuma, restic, Archify

### Agentville (Open source · macOS)

Free, open-source Claude Code desktop mod (plugin agentville@jandresgarcia) that draws every Claude Code session as a pixel-art office. The Lead and its subagents sit at desks, agents that need approval wait in line at your desk, and one panel approves, answers and messages every session, shows each session's spend and each agent's plan, and runs an optional team flow triaged small, medium or large. English and Spanish panel, macOS, no network calls.

Case study: https://www.jandresgarcia.dev/projects/agentville/
Live app: https://agentville.jandresgarcia.dev

How a run works:

1. You run several Claude Code sessions; each Lead and its subagents becomes an office.
2. With the team flow on, the Lead triages every change small, medium or large and hands it to the plugin's agents.
3. The mod's hooks write each session's heartbeat, masking obvious tokens first.
4. It lands in the sessions folder, on this machine only.
5. The panel reads every status file every 3 seconds and draws each session as an office.
6. An agent that needs your OK walks to your desk and waits in line; its session holds the request for about 8 seconds.
7. Press A or R: the panel writes a signed order for that session and the exact command the card showed.
8. The session reads its orders every 1.5 seconds, checks the signature and acts once. Past the hold, it asks in its own prompt.

Components:

- Claude Code sessions (Lead + subagents): Each session is an office with its team: the Lead, the session's main agent, and its subagents.
- Team flow (Optional · 9 agents): The Lead triages each change small, medium or large by risk. The Secretary and Product check new or high-impact work against your goals file, the spec-writer writes the spec, builders build, up to four reviewers (security, UX, UI design, code) review, and the approver closes a large change.
- Mod hooks (Heartbeat · order check): The mod's hooks in every session write its status and read its orders. Obvious tokens are masked before anything is written.
- Status files (sessions/<id>.json): One heartbeat file per session in ~/.claude/agentville, a folder only you can open (chmod 700): agents and states, permission requests, spend and recent messages. Nothing leaves the machine.
- Signed orders (control/<id>.json · every 1.5 s): The panel writes orders here and each session reads its own file every 1.5 seconds. Every order is signed with HMAC-SHA256 for its target session, counts for two minutes and acts once.
- Panel (/agentville · every 3 s): Opened with /agentville in the Claude desktop app, it reads every status file every 3 seconds. English or Spanish, with a guided tour by Gem, the Secretary.
- Pixel office (Desks · lounge · usage): Every session gets an office with its desks, plan board and usage screen (spend, context, tool calls). Idle agents rest in the lounge; click an agent to see its plan, steps and conversation.
- Your desk (Approve A · Reject R): Permission requests wait in line here. A session holds a request for about 8 seconds, then falls back to its own prompt. Approve allows exactly what the card shows.

Technologies: Claude Code, TypeScript, Claude Code plugins, Claude Code hooks, Subagents, HMAC-SHA256

## How to cite

Julian Garcia (Julian Andres Garcia Mosquera), AI Engineer & Fullstack Software Engineer, Medellín, Colombia. Portfolio: https://www.jandresgarcia.dev/