Background
L47
LiveSkills #001YER · AI EngineerJob applicationactive

Hi YER.

I didn't want to just send you a CV.So I built this instead.

I'm a Full-Stack Software Engineer working with LLM-driven development, AI agents and rapid product engineering. This page was created specifically for my application to your AI Engineer position in Lisbon — and every claim on it links back to code I can show you.

See how I engineerSelected work

LisbonBrief source: Role brief supplied by the candidaterequirements pending confirmation

Evidence items
25
Verified
24
Systems shown
4
Requirements addressed
9

Positioning

Full-Stack Software Engineer · LLM-Driven Development · Agentic Systems · Product Engineering

I build software end to end and use AI as an engineering multiplier — not as a replacement for understanding the system.

The work is hands-on full-stack product development: reading existing codebases, structuring systems, building frontend and backend capabilities, integrating services that carry money, and shipping to production.

Over time I moved LLMs and coding agents into that workflow. The interesting part was never generating code — it was designing the checks around generation: schema validation, role boundaries, execution budgets and audit trails.

Evidence contract

Repositories audited 2026-08-30

Every claim on this page carries a confidence level. Nothing is stated as fact because it sounds good in an application — it is stated because there is an artefact behind it, and the strength of that artefact is labelled.

VERIFIED24
Read directly from code, config, schema, tests or a running deployment.
DOCUMENTED0
Solid documentation exists; the implementation was not audited in this pass.
REPORTED1
Self-reported working practice, recorded but not independently measured.

What I build

Capabilities, each tied to something that exists

Every capability below links to evidence read directly from a repository on the audit date. Expand one to see the artefacts behind it.

Build

3 capabilities

Shipping applications people actually use

  • Full-stack product development

    VERIFIED

    Public experience, back office, API layer and database in the same codebase — including the boring parts: roles, permissions, invoices, error states.

    seen in AG Menu

  • Third-party integrations that carry money

    VERIFIED

    Payments, invoicing, OAuth and booking protocols where a silent failure reaches a paying customer, so the boundary gets contract tests.

    seen in AG Menu

  • Backend services and data

    VERIFIED

    Python and TypeScript services, relational migrations, document-store rules, invariants that must hold under concurrency.

    seen in Alt-Radar · AG Menu

Engineer

3 capabilities

Keeping a growing system understandable

  • Reading and extending existing systems

    VERIFIED

    Most of the work is not greenfield. Understand the system first, change the smallest surface that solves the problem, leave the architecture intact.

    seen in AG Menu · Evolution Protocol (EvoPro)

  • Schema-driven development

    VERIFIED

    Define the contract before the interface. Validate at the boundary. Let the validated shape drive the rendering instead of hardcoding it.

    seen in YouLearn · Evolution Protocol (EvoPro)

  • Testing, CI and deployment

    VERIFIED

    Contract tests at integration boundaries, unit tests for pure logic, end-to-end for the paths that matter, and a pipeline that runs them.

    seen in Alt-Radar · AG Menu · YouLearn

Apply AI

4 capabilities

LLMs and agents as engineering components

  • LLM features inside real products

    VERIFIED

    Schema-constrained generation, server-side key handling, graceful degradation when the model is unavailable — shipped, not demoed.

    seen in AG Menu

  • Agentic system design

    VERIFIED

    Agents with declared roles and enforced boundaries, a state machine driving the loop, budgets capping autonomy, and an event log that makes a run reconstructable.

    seen in Evolution Protocol (EvoPro)

  • Treating model output as untrusted input

    VERIFIED

    Parse, validate against a schema, hash for audit, reject on boundary violation. The interesting engineering is in what happens after generation.

    seen in Evolution Protocol (EvoPro) · AG Menu

  • AI-native engineering workflow

    VERIFIED

    Agent operating rules committed to the repository next to the code they govern, so the working agreement is versioned like everything else.

Own the outcome

3 capabilities

From problem statement to deployed product

  • Idea to deployed product

    VERIFIED

    Problem framing, architecture, implementation, tests, deployment and the iteration after launch — repeatedly, across different domains.

    seen in AG Menu · Alt-Radar · YouLearn

  • Rapid prototyping with a path to production

    VERIFIED

    AG47 Labs is where experiments start; the ecosystem is where the ones that survive move. This page is an instance of that pipeline.

  • Evidence discipline

    VERIFIED

    Separating what the code proves from what the documentation says from what someone remembers — and labelling which is which.

    seen in Evolution Protocol (EvoPro)

How I engineer

The loop I actually run

Steps marked with an agent badge are where AI participates. The unmarked ones are deliberately not delegated.

  1. Problem

    not delegated

    State what actually has to be true when this is done. Not the ticket — the outcome.

  2. Understand the system

    not delegated

    Read the existing code, routes, schemas and config before proposing anything. This step is never delegated.

  3. Architecture

    not delegated

    Decide the smallest change that solves the problem without widening the blast radius.

  4. Build

    agent-assisted

    Implement in the editor, in the real codebase, following the conventions already there.

  5. AI-assisted execution

    agent-assisted

    Agents handle mechanical breadth — sweeps, scaffolds, refactors — under rules committed to the repository.

  6. Review

    not delegated

    Read every diff. Generated code is a proposal, not a commit.

  7. Test

    agent-assisted

    Contract tests at integration boundaries, unit tests for logic, end-to-end for the paths users take.

  8. Deploy

    not delegated

    Through the pipeline, not from a laptop. Vercel or Cloud Run depending on the workload.

  9. Observe

    not delegated

    Telemetry, logs and audit trails, so the next iteration starts from data instead of opinion.

  10. Iterate

    agent-assisted

    Feed what was learned back into the architecture and the agent rules.

“I don't delegate understanding to AI. I use AI to increase engineering throughput.”

Selected engineering work

Four systems, four different problems

Problem, what was built, how it is structured, and what each one demonstrates. Stack lists are extracted from the repositories, not from memory.

01liveVERIFIED

AG Menu

Full-stack restaurant platform, live in production

Lines of TypeScript
~69,000
app/ components/ lib/ hooks/ line count
API route handlers
41
app/api/**/route.ts
Commits on main
263
git rev-list --count HEAD
Test & ops scripts
37
scripts/

Problem

Restaurants need a public digital presence, a way to take reservations and orders, and a back office to run all of it — usually stitched together from four disconnected tools, none of which talk to their invoicing or to Google.

What I built

  • Public restaurant pages, city directories and digital menus with structured data
  • Merchant back office: menu, orders, reservations, waitlist, CRM, team, invoicing, analytics
  • Authentication and four-role authorization enforced on the server and again in database rules
  • Reservations exposed to Google Reserve, plus Google Business OAuth for the merchant
  • Stripe billing with a webhook handler and InvoiceXpress issuing with SAF-T export
  • Six in-product LLM endpoints for menu copy, chat, ads, analytics, room planning and waitlist

Architecture

  • Next.js App Router — 34 page routes, 41 API route handlers
  • Firebase client + Admin SDK; Firestore as the system of record
  • Authorization resolved server-side, then re-enforced in 308 lines of security rules
  • Third-party surface isolated behind dedicated route handlers (Stripe, Google, InvoiceXpress)
  • Contract tests pinned to the boundaries that break silently

Stack

  • Next.js 16
  • React 19
  • TypeScript
  • Tailwind v4
  • Firebase / Firestore
  • firebase-admin
  • Stripe
  • Google APIs
  • Gemini (@google/genai)
  • Playwright
  • Vercel
  • Cloud Run

What it demonstrates

  • Working inside a large codebase without rewriting it
  • Multi-role product modelling, not just CRUD screens
  • Third-party integration where failure is visible to a paying customer
  • Shipping LLM features under real product constraints

Honest limit — The application repository is private, so the links point to the running product rather than to source.

agmenu.pt(opens in a new tab)AG47 ecosystem entry
02betaVERIFIED

Evolution Protocol (EvoPro)

A governance kernel for AI-assisted software engineering

Kernel modules
85
src/evolution_kernel/**/*.py
Lines of Python
~18,000
source line count
Test modules
37
tests/
Recorded host cycles
5
alt-radar .evolution/cycles/*.json

Problem

Coding agents are fast and forgetful. Left ungoverned they lose architectural context between sessions, produce plausible output nobody validated, and quietly widen the scope of a change. The failure mode is not bad code — it is unaccountable code.

What I built

  • A state machine that moves a change through observe → plan → execute → validate with recorded transitions
  • A CognitiveGateway that schema-validates every model response and hashes input and output for audit
  • Role boundaries enforced in code: an analyst agent that proposes a solution is denied, not merged
  • Guardrails and budgets — agent calls, tokens and execution time are capped per cycle
  • An event ledger and decision trace so a change can be reconstructed after the fact
  • A provider adapter layer (base / Gemini / mock) keeping the kernel model-agnostic and testable offline

Architecture

  • 23 core modules: state machine, evolution graph, event ledger, decision trace, guardrails, scope policy, continuity, baseline
  • 8 engines: run loop, judge, gauntlet, policy, impact, benchmark, sprint
  • 30 agent modules: observer, planner, executor, validator and specialised analysts
  • 24 bundled JSON schemas constraining agent and artifact contracts
  • Two CLI entry points — evolution and second-brain

Stack

  • Python ≥3.10
  • jsonschema
  • pytest
  • CLI (setuptools entry points)
  • MIT licence

What it demonstrates

  • Designing agentic systems as engineering, not prompting
  • Treating LLM output as untrusted input that must pass validation
  • Auditability and human governance as first-class requirements
  • Reasoning about autonomy limits before granting autonomy

Honest limit — This is a working kernel with recorded runs against a real host project — not a fleet running unattended in production. The distinction is deliberate.

Protocol documentation
03liveVERIFIED

YouLearn

Schema-driven knowledge transformation

Assertions passing
49 / 49
test runner executed during this audit
Section types
11
schema section discriminants + section components

Problem

Turning a long recorded source into something learnable means imposing structure on it. If that structure lives in components, every new content type becomes a new page. If it lives in a schema, content and UI can evolve independently.

What I built

  • A Zod-validated domain: sources, authors, provenance, learning metadata and eleven section types
  • A section registry that maps validated section types to React components
  • Provenance utilities that deep-link back to the exact second of the source
  • Library derivation, search, filtering, stats and compression ratios computed from the data
  • A Markdown/Obsidian exporter with YAML frontmatter and attribution

Architecture

  • Schema first: schema/types.ts and schema/validation.ts define the contract
  • Content shape drives rendering through SectionRegistry, not the other way round
  • Pure library and provenance functions kept outside components so they are testable
  • A standalone verification runner covering validation, derivation and formatting

Stack

  • Next.js
  • React 19
  • TypeScript
  • Zod
  • Tailwind

What it demonstrates

  • Schema-driven development and validation at the boundary
  • Provenance and attribution treated as product requirements
  • Modular UI architecture that survives new content types
  • Writing the tests that actually run

Honest limit — Automatic ingestion was still manual at the audited stage — the pipeline exists, the autonomy does not.

Live on AG47
04liveVERIFIED

Alt-Radar

Python API + Next.js web, shipped through CI

API test modules
27
apps/api/tests/
CI workflows
2
.github/workflows/

Problem

A market signal product needs a real backend — scheduled ingestion, migrations, invariants that must hold under concurrency — and a frontend that never shows a number it cannot justify.

What I built

  • A Python API with Alembic migrations and 27 pytest modules covering ingestion, invariants, concurrency and security
  • A Next.js web application with Vitest unit tests and Playwright end-to-end coverage
  • A path-filtered GitHub Actions verify workflow plus a Cloud Run deployment pipeline
  • Containerised local and deployed environments via Dockerfile and docker-compose

Architecture

  • Monorepo split into apps/api and apps/web with independent toolchains
  • Database migrations versioned with Alembic
  • CI gates scoped by changed paths so unrelated work does not pay the cost
  • The same repository also hosts the recorded EvoPro evolution cycles

Stack

  • Python
  • FastAPI-style service layer
  • Alembic
  • pytest
  • Next.js
  • Vitest
  • Playwright
  • Docker
  • GitHub Actions
  • Cloud Run

What it demonstrates

  • Backend engineering beyond the JavaScript ecosystem
  • Migrations, invariants and concurrency treated seriously
  • CI/CD as part of the product, not an afterthought
Live on AG47

Your requirements → my evidence

Where the fit is — and where it is not

Requirements are paraphrased from the role brief, not copied. The last row is a stated gap rather than a match.

  • YER needs

    Strong software engineering foundations across the full stack

    What I can show

    Building and maintaining production applications end to end — public surface, back office, API layer, database rules and the authorization that ties them together.

    • AG Menu
    VERIFIED

  • YER needs

    Hands-on work with LLMs in real applications

    What I can show

    Six LLM endpoints shipped inside a live product, each constraining the model with a JSON response schema, keeping the key server-side and failing closed when the model is unavailable.

    • AG Menu
    • Evolution Protocol (EvoPro)
    VERIFIED

  • YER needs

    AI agents, orchestration and automation

    What I can show

    A working agentic kernel: role-bounded agents, a state machine driving the loop, schema validation on every model response, execution budgets and an event ledger — with cycles recorded against a real host project.

    • Evolution Protocol (EvoPro)
    VERIFIED

  • YER needs

    Backend services, APIs and integrations

    What I can show

    Stripe billing with webhooks, InvoiceXpress issuing, Google Reserve booking across 12 endpoints, Google Business OAuth, plus a separate Python API with migrations and concurrency tests.

    • AG Menu
    • Alt-Radar
    VERIFIED

  • YER needs

    Turning ideas into working products quickly

    What I can show

    AG47 Labs is the prototyping surface and the ecosystem is where surviving experiments move. This page was built through that same pipeline as a new Labs mini-app.

    • YouLearn
    VERIFIED

  • YER needs

    Working with data, schemas and validation

    What I can show

    Zod-validated domain models, JSON Schema contracts between agents, Firestore security rules and Alembic migrations — validation placed at the boundary rather than inside components.

    • YouLearn
    • Evolution Protocol (EvoPro)
    • Alt-Radar
    VERIFIED

  • YER needs

    Testing, deployment and production ownership

    What I can show

    Contract tests on the boundaries that fail silently, Playwright and Vitest and pytest where each fits, GitHub Actions gating merges, and deployment through Vercel or Cloud Run.

    • AG Menu
    • Alt-Radar
    VERIFIED

  • YER needs

    Experimentation mindset and independent judgement

    What I can show

    Experiments are run against real repositories with explicit evidence levels, and results that do not hold up are labelled rather than promoted.

    • Evolution Protocol (EvoPro)

    Where a capability is conceptual rather than operational — autonomous agent fleets, for example — it is labelled that way on this page.

    VERIFIED

  • Stated gap

    Machine learning research and model training

    Where I actually am

    Not the strength being offered. The work here is application-layer AI engineering: integrating, constraining, validating and shipping models — not training or fine-tuning them.

    Stated explicitly so the fit can be assessed accurately. If the role is weighted towards ML research, this is the gap.

    VERIFIED

Technical capability map

Technologies, grouped by where they were used

No percentages. Each group names the projects where these technologies were observed during the audit.

Frontend

  • Next.js (App Router)
  • React 19
  • TypeScript
  • Tailwind CSS v4
  • Framer Motion
  • PWA

observed in AG Menu · AG47 · YouLearn · Alt-Radar web

Backend

  • Node.js route handlers
  • Python services
  • REST APIs
  • Webhooks
  • OAuth 2.0
  • Server-side authorization

observed in AG Menu · Alt-Radar API

Data

  • Firestore
  • Security rules
  • Alembic migrations
  • Zod schemas
  • JSON Schema
  • Structured logging

observed in AG Menu · Alt-Radar · YouLearn · EvoPro

AI / LLM

  • Gemini via @google/genai
  • Schema-constrained output
  • Provider adapters
  • Prompt & system-instruction design
  • Graceful degradation

observed in AG Menu · EvoPro

Agentic systems

  • Role-bounded agents
  • State machines
  • Event ledgers
  • Decision traces
  • Execution budgets
  • Human governance gates

observed in EvoPro (with recorded cycles on Alt-Radar)

Infrastructure

  • Vercel
  • Google Cloud Run
  • Docker & docker-compose
  • GitHub Actions
  • Environment & secret handling

observed in AG Menu · Alt-Radar · AG47

Testing

  • Contract tests
  • Playwright
  • Vitest
  • pytest
  • Smoke & integration scripts

observed in AG Menu · Alt-Radar · YouLearn

Product engineering

  • Multi-role modelling
  • SEO & JSON-LD
  • Analytics & telemetry
  • GDPR consent flows
  • Billing & invoicing

observed in AG Menu · AG47

AI-native engineering

How AI sits inside the workflow

These are engineering instruments with declared roles, not a list of tools I have opened.

Claude Code

VERIFIED

Repository-wide reasoning and multi-file changes, run against committed operating rules rather than ad-hoc prompts.

Codex

REPORTED

Scoped implementation passes and mechanical refactors where the target is well specified.

Antigravity

REPORTED

Longer autonomous passes on tasks with a clear acceptance criterion and a small blast radius.

Gemini (@google/genai)

VERIFIED

The model actually shipped in product features — always behind a JSON schema and a server-side key.

“AI is part of my engineering workflow, not a substitute for understanding the system.”

The label that fits is software engineer using AI-native development workflows — not an AI tools user. The judgement about what to build, what to reject and what to keep stays human; the throughput is where the models help.

About this page

This application is also a small product

LiveSkills is the engine behind this page — a new mini-app inside AG47 Labs, built for this application and designed to be reused.

How this page is generated

  1. 1Evidence catalogdata/candidate.ts — shared across presentations
  2. 2Presentation configdata/yer.ts — this opportunity only
  3. 3Registrylib/registry.ts — slug → presentation
  4. 4Enginecomponents/ — typed, reusable sections
  5. 5Route/labs/liveskills/[slug] → /labs/liveskills/yer

A presentation for another company is a new data file and one registry entry. The engine, the components and the evidence catalog stay untouched — which is the actual test of whether the abstraction was worth building.

  • Presentation engine, not a landing page

    A typed presentation model, a shared evidence catalog and a dynamic route. A second company costs one data file — not a second page.

  • Evidence graph

    Capabilities, projects and requirement matches all reference the same evidence catalog by id, so nothing can be claimed twice from different sources.

  • Explicit confidence levels

    Every claim carries VERIFIED, DOCUMENTED or REPORTED. Anything unverified is either labelled or absent.

  • Built inside an existing system

    Added to the AG47 codebase under its Labs layout, design system and conventions — no parallel app, no framework swap, no existing route touched.

  • Accessible and responsive

    Semantic landmarks, keyboard-operable disclosures, visible focus states, and motion that respects prefers-reduced-motion.

  • Honest about its own gaps

    The role requirements below still need confirming against the live posting, and personal details are marked pending rather than invented.

See the LiveSkills lab

Next step

This wasn’t a template.

I built this page because I saw your AI Engineer position and think the way I work lines up with the kind of engineering you are building. If that reads right, the fastest next step is a technical conversation — I am happy to walk through any of the systems above, including the parts that are still rough.

Email dev@ag47.ptAG47 ecosystemSource of this site

What this page does not prove

  • This page was written with AI assistance, as is every other system described on it. The evidence, the audit and the architectural decisions are mine.
  • The AG Menu and Evolution Protocol repositories are private, so those links point to the running product and its documentation rather than to source. Source access can be arranged for a technical conversation.
  • Role requirements are paraphrased from the brief I was given and have not been confirmed against the live posting.

Pending confirmation

  • Full professional name and the direct contact to publish
  • Public profiles (LinkedIn / personal GitHub) to link
  • Education, certifications and formal years of experience
  • Availability, hybrid arrangement and work status in Portugal

Listed rather than invented. Anything here is shared directly in a conversation.

47%