Service 01

Intelligent software

SaaS software with AI as a native component.

Deliverables
  • Full product: auth, DB, UI, API, with native Agentic AI
  • Deployed to production (Docker + Scaleway)
  • Automated test suite (vitest + e2e)
  • Technical documentation and runbook
  • CI/CD operational from day one
Working method
[phase] discovery
skill(s)grill-me
inputbusiness_brief · regulatory_constraints · data_sources[]
scan_processes()
feasibility_scoring()
formalise_spec(brief) → spec_prd
outputspec_prd
[phase] architecture
agent(s)backend-api
inputspec_prd
graph_design()
stack_choice()
decompose_verticals()
outputtech_spec · db_schema · verticals[]
[phase] build_vertical (×n)
agent(s)backend-api·ui
inputvertical_spec
schema → api_route → ui_component → test
if qa.fail(): build.fix(diff); retry()
outputversioned_code · tests_green
[phase] security_review
inputversioned_code
owasp_scan()
dependency_audit()
secrets_check()
if vulnerability.found(): patch(); rerun()
outputsecurity_report · hardened_code
[phase] deploy
agent(s)devops
inputvalidated_artefacts
github_actions → docker_build → scaleway_push
if health_check.fail(): rollback()
outputproduction · monitoring_active
[phase] continuous_ticketing
skill(s)grill-me
inputfeature_requests[] · bugs[] · user_feedback[]
create_ticket(request)
agent_prioritize(tickets[]) → ordered_backlog
agent_spawn(ticket) → agent.resolve(ticket)
grill-me(ticket) → human_review() → if approved: merge_and_deploy()
outputordered_backlog · shipped_features · zero_regression
[phase] iterate
inputlangfuse.traces()
ab_test_prompts()
detect_regressions()
optimize_cost()
outputoptimised_prompts · cost_reduced
Typical stack

Next.js 16 + React 19

App Router, Server Components, streaming RSC for LLM responses

Prisma + PostgreSQL

Typed ORM, versioned migrations, schema as single source of truth

Claude API (Sonnet / Haiku)

Model routing per task: Haiku for classification, Sonnet for reasoning

LangGraph

Stateful orchestration when the workflow requires cycles or human-in-the-loop

Langfuse

LLM tracing, cost per feature, anomaly detection: open source, self-hosted

Docker + Scaleway

Reproducible container, fr-par cloud, GDPR-native

Client inputs
  • Business brief: what the product must solve, and for whom
  • Access to existing data (APIs, exports, database)
  • User personas and priority use cases
  • Regulatory or technical constraints (GDPR, SSO, SLA)
Orchestration

Linear pipeline with correction loops. The QA agent sends a diff back to the build agent when a test fails: the vertical does not ship until tests are green. Guardrails on every critical output: the architecture agent validates the schema before the build starts, the deploy agent validates artefacts before the production push. No irreversible action without explicit validation.

Expected outputs
  • Versioned source code, ready for team handoff
  • Complete technical documentation (README, ADRs, runbook)
  • Operational CI/CD with automated tests
  • Configured Langfuse dashboard (costs, traces, alerts)
  • Incident runbook (outages, rollback, escalation)
ROI measurement
Dev cost2-3× lower vs. traditional team on equivalent scope
Time-to-marketFirst vertical shipped in 1-2 weeks, not 3 months
Marginal AI costNear zero per feature once prompts are optimised
MaintenanceAutomated tests + CI/CD reduce regressions at every deployment
Self-learning loops

Langfuse traces → A/B test prompts. Every LLM call is traced. We identify the most expensive prompts and test variants: fewer tokens, same quality.

User feedback → fine-tuning. Poorly rated outputs feed a dataset of negative examples. Critical prompts are refined each sprint.

Final objective

A product that learns from its users, reduces its running costs over time, and is maintained by a fraction of a team. AI is not a feature bolted on afterwards: it is in the architecture from the first data schema.

Related resources

Build your product?

Describe your idea. We reply within 24h.

Describe my project →