# Arnaud Ramponneau
# Temet Professional Profile
# https://temetapp.com/a/22cd91b5de1fdc50

I bridge code, design and strategy.

## Mission capabilities

### Workflow automation and release stabilization
- Category: Infrastructure
- Problem treated: The delivery pipeline needs less manual friction and more stable release behavior.
- Entry signals: Work is repetitive or hand-driven; Release steps keep interrupting delivery; Automation can reduce the amount of coordination work
- Method: Turn repetitive work into a stable workflow; Treat the release path as a system worth tuning; Reduce manual drag before increasing throughput; Decision rule: Decision criterion: "il faut absolument corriger l’idempotence de l’injection et rendre le prompt de deep ana"
- Deliverables: Automation recommendations; Release stabilization plan; Workflow notes
- Tools used: git; docker; python; uv
- Inputs required: Current workflow; Release process; Manual pain points
- Exclusions: Automation that adds more moving parts than it removes; Release fixes without a workflow view; Anti-pattern: "jamais propagé au narrateur"
- Protocol preview:
  - Goal: The delivery pipeline needs less manual friction and more stable release behavior.
  - Intake questions: What is the current current workflow?; What is the current release process?; What is the current manual pain points?
  - Core steps: Clarify the context; Find the main friction; Frame the next decisions; Prepare the delivery path
  - Guardrails: Automation that adds more moving parts than it removes; Release fixes without a workflow view; Anti-pattern: "jamais propagé au narrateur"
- Evidence examples: 5 git commands out of 30 total tool calls (16.7%); 46 git commands out of 587 total tool calls (7.8%); Bash detected 21/36 times (58.3%)
- Decision criteria: Decision criterion: "il faut absolument corriger l’idempotence de l’injection et rendre le prompt de deep ana"; Decision criterion: "il faut préciser "IA" ou "AI quelque part ! sinon on comprend pas"

### Architecture audit and risk reduction
- Category: Software architecture
- Problem treated: The system needs a careful read before changes are made, because hidden risk is expensive.
- Entry signals: The codebase has many moving parts; A change could break boundaries or contracts; The team needs a reliable view of technical risk before moving
- Method: Read the system before changing it; Map the constraints around modules, boundaries, and dependencies; Reduce the risk surface before accelerating implementation; Decision rule: Decision criterion: "il faut changer le cli ? cela me parait consommer énormément de tokens... on était rest"
- Deliverables: Architecture audit; Risk map; Recommended change sequence
- Tools used: curl
- Inputs required: Relevant modules or subsystems; Known risk areas; Recent change history
- Exclusions: Large rewrite without prior reading; Architecture work with no evidence trail; Anti-pattern: "never explains how the publisher authorizes a follower. Right now “follow by address a"
- Protocol preview:
  - Goal: The system needs a careful read before changes are made, because hidden risk is expensive.
  - Intake questions: What is the current relevant modules or subsystems?; What is the current known risk areas?; What is the current recent change history?
  - Core steps: Clarify the context; Find the main friction; Frame the next decisions; Prepare the delivery path
  - Guardrails: Large rewrite without prior reading; Architecture work with no evidence trail; Anti-pattern: "never explains how the publisher authorizes a follower. Right now “follow by address a"
- Evidence examples: Read detected 8/36 times (22.2%); Read detected 17/35 times (48.6%); Grep detected 10/35 times (28.6%)
- Decision criteria: Decision criterion: "il faut changer le cli ? cela me parait consommer énormément de tokens... on était rest"

### Codebase modernization without regressions
- Category: Full stack development
- Problem treated: The codebase needs to move forward without breaking the product on the way.
- Entry signals: Refactoring pressure is high; The team needs modernization with guardrails; Change risk is easier to create than to manage
- Method: Modernize in small controlled steps; Keep the path to verification visible at all times; Preserve behavior while changing structure
- Deliverables: Modernization plan; Regression-safe change sequence; Verification checkpoints
- Tools used: gh
- Inputs required: Current code area; Risk tolerance; Known failure modes
- Exclusions: Unbounded rewrite work; Change without verification strategy
- Protocol preview:
  - Goal: The codebase needs to move forward without breaking the product on the way.
  - Intake questions: What is the current current code area?; What is the current risk tolerance?; What is the current known failure modes?
  - Core steps: Clarify the context; Find the main friction; Frame the next decisions; Prepare the delivery path
  - Guardrails: Unbounded rewrite work; Change without verification strategy
- Evidence examples: Edit detected 170/587 times (29.0%); Edit detected 4/15 times (26.7%)

### B2B time-to-market reduction
- Category: Product management
- Problem treated: A B2B product needs to move from idea to shipped value faster without sacrificing quality.
- Entry signals: Prototype cycles are too long; Iteration speed is lower than the team expects; The team ships, but releases do not land quickly enough
- Method: Look at how ideas become tests, tests become decisions, and decisions become shipped work; Reduce loop length before attempting to increase output; Keep quality constraints visible while cutting unnecessary delay
- Deliverables: Time-to-market diagnosis; Short-loop delivery plan; Release acceleration recommendations
- Tools used: playwright; google-analytics; gh
- Inputs required: Recent product iterations; Release cadence; Known quality or review constraints
- Exclusions: Faster shipping without a quality boundary; Roadmap theatre without real throughput improvement
- Protocol preview:
  - Goal: Shorten the path from idea to shipped value without hiding quality risks.
  - Intake questions: What is the current recent product iterations?; What is the current release cadence?; What is the current known quality or review constraints?
  - Core steps: Map the current loop; Find unnecessary waiting time; Protect the quality boundary; Sequence the shortest improvements
  - Guardrails: Faster shipping without a quality boundary; Roadmap theatre without real throughput improvement
- Evidence examples: The signal behind Rapid prototyping and iteration appears repeatedly in your sessions. It is not just a topic you touch once. It shows up as a repeated working habit

### Technical and product decision-making under ambiguity
- Category: Consulting
- Problem treated: A technical or product decision must be made now with incomplete information, and the cost of waiting exceeds the cost of choosing.
- Entry signals: The team is stuck between two or more credible paths; Waiting for perfect information would block delivery; The decision affects code, product, and organization at the same time
- Method: Name the constraints that cannot move; Surface the real tradeoffs behind the stated options; Reduce the choice to the smallest useful set; Keep the recommendation honest about what is uncertain; Decision rule: Decision criterion: "Il faut réorienter mes postes et réponses pas juste sur ce que vent temet, sur sur mes c"
- Deliverables: Decision brief with options compared on the dimensions that matter; Clear recommendation with reasons and risks; Next-step plan that can be validated in one iteration
- Tools used: temet; google-analytics
- Inputs required: The specific decision and its deadline; Known constraints (team, code, time, budget); Options currently considered; Stakeholders who must commit
- Exclusions: Unlimited-scope strategy without a decision to make; Recommendations that ignore the real constraints; Pure facilitation without a technical point of view; Anti-pattern: "jamais stocké systématiquement — les Decision Traces. Le pourquoi derrière chaque décis"
- Protocol preview:
  - Goal: A technical or product decision must be made now with incomplete information, and the cost of waiting exceeds the cost of choosing.
  - Intake questions: What is the current the specific decision and its deadline?; What is the current known constraints (team, code, time, budget)?; What is the current options currently considered?; What is the current stakeholders who must commit?
  - Core steps: Clarify the context; Find the main friction; Frame the next decisions; Prepare the delivery path
  - Guardrails: Unlimited-scope strategy without a decision to make; Recommendations that ignore the real constraints; Pure facilitation without a technical point of view
- Evidence examples: The signal behind Technical decision-making under ambiguity appears repeatedly in your sessions. You also make decisions that reinforce it: Decision criterion: "Il faut réorienter mes postes et réponses pas juste sur ce que vent temet, sur sur mes c"; The signal behind Technical decision-making appears repeatedly in your sessions. It is not just a topic you touch once. It shows up as a repeated working habit
- Decision criteria: Decision criterion: "Il faut réorienter mes postes et réponses pas juste sur ce que vent temet, sur sur mes c"; Decision criterion: "always double checking any Claude implementation, with Codex 5.4, it always finds bugs,"

### Content strategy and editorial structuring
- Category: Content strategy
- Problem treated: Information needs a clearer shape so it becomes useful, legible, and reusable.
- Entry signals: Messages or documents need a better structure; The content works better when the argument is staged clearly; The audience needs a simpler reading path
- Method: Shape the content around the way it will be read; Prefer structure before polish; Make the reading path visible from the start
- Deliverables: Editorial structure; Content outline; Readable message hierarchy
- Inputs required: Audience; Message goal; Content constraints
- Exclusions: Polish without structure; Editorial work with no target reading flow
- Protocol preview:
  - Goal: Information needs a clearer shape so it becomes useful, legible, and reusable.
  - Intake questions: What is the current audience?; What is the current message goal?; What is the current content constraints?
  - Core steps: Clarify the context; Find the main friction; Frame the next decisions; Prepare the delivery path
  - Guardrails: Polish without structure; Editorial work with no target reading flow
- Evidence examples: 4 files touched in content (9.3% of 43 files); 3 files touched in content (13.0% of 23 files)

### Feature delivery in complex codebases
- Category: Full stack development
- Problem treated: A feature must be delivered through a codebase that already has depth, constraints, and dependency pressure.
- Entry signals: Implementation is straightforward only on paper; Feature work needs decomposition to move safely; The product needs delivery, not just design intent; Observed pattern: Feedback-Loop Delivery; You drive work through short correction cycles
- Method: Break the feature into executable steps; Keep the implementation path tied to the current system; Track the dependency chain so progress stays visible; Decision rule: Decision criterion: "il faut rendre plus rapide ! mais c'est noirmal d'avoir les 2 ici ? "; Feedback-Loop Delivery — You drive work through short correction cycles
- Deliverables: Delivery plan; Implementation sequence; Dependency notes
- Tools used: playwright; gh
- Inputs required: Feature scope; Affected code areas; Known blockers
- Exclusions: Speculation without implementation detail; Feature work that ignores system constraints; Anti-pattern: "jamais utiliser de anthropic api key, car on ne va jamais demander cela à l'utilisateur"; Anti-pattern: "Never modify schema without written spec") instead of additional skills."
- Protocol preview:
  - Goal: A feature must be delivered through a codebase that already has depth, constraints, and dependency pressure.
  - Intake questions: What is the current feature scope?; What is the current affected code areas?; What is the current known blockers?
  - Core steps: Clarify the context; Find the main friction; Frame the next decisions; Prepare the delivery path
  - Guardrails: Speculation without implementation detail; Feature work that ignores system constraints; Anti-pattern: "jamais utiliser de anthropic api key, car on ne va jamais demander cela à l'utilisateur"
- Evidence examples: The signal behind API design and specification appears repeatedly in your sessions. You also make decisions that reinforce it: Decision criterion: "il faut rendre plus rapide ! mais c'est noirmal d'avoir les 2 ici ? "; The signal behind Test-driven delivery appears repeatedly in your sessions. You also make decisions that reinforce it: Decision criterion: "il faut sortir de la boucle d’édition et lancer un test structuré"; The signal behind Code standards and quality appears repeatedly in your sessions. You also make decisions that reinforce it: Decision criterion: "toujours juste 2 traces = recurring, 3+ = stable_rule, sans condition sur distinctSession"
- Decision criteria: Decision criterion: "il faut rendre plus rapide ! mais c'est noirmal d'avoir les 2 ici ? "; Decision criterion: "il faut sortir de la boucle d’édition et lancer un test structuré"; Decision criterion: "il faut adapter ou compléter le @.claude/SPEC_28_First_Train_on_the_Rails.md ?"

### Frontend and component architecture
- Category: Full stack development
- Problem treated: The interface needs a stronger structure so it stays coherent as the product grows.
- Entry signals: UI complexity is increasing; Components need clearer boundaries; The rendering model is becoming harder to maintain; Observed pattern: Product Taste; You notice what feels right before it is fully rationalized
- Method: Treat the UI as a structure problem, not just a styling problem; Preserve component boundaries while the interface evolves; Keep the surface coherent across states and flows; Decision rule: Decision criterion: "il faut choisir: soit API agent-friendly directe, soit enveloppe uniforme. Aujourd’hui v"; Product Taste — You notice what feels right before it is fully rationalized
- Deliverables: Component architecture notes; UI structure recommendations; Implementation guardrails
- Tools used: chrome-devtools; npm; playwright; pnpm
- Inputs required: Current UI structure; State complexity; Design constraints
- Exclusions: Visual changes without structural thinking; Component work with no boundary clarity; Anti-pattern: "never replaces patterns, never recomputes loops, and never saves or re-renders anythin"
- Protocol preview:
  - Goal: The interface needs a stronger structure so it stays coherent as the product grows.
  - Intake questions: What is the current current UI structure?; What is the current state complexity?; What is the current design constraints?
  - Core steps: Clarify the context; Find the main friction; Frame the next decisions; Prepare the delivery path
  - Guardrails: Visual changes without structural thinking; Component work with no boundary clarity; Anti-pattern: "never replaces patterns, never recomputes loops, and never saves or re-renders anythin"
- Evidence examples: The signal behind Frontend component architecture appears repeatedly in your sessions. You also make decisions that reinforce it: Decision criterion: "il faut choisir: soit API agent-friendly directe, soit enveloppe uniforme. Aujourd’hui v"; 2 files touched in components/ (10.5% of 19 files); 4 files touched in components/ (19.0% of 21 files)
- Decision criteria: Decision criterion: "il faut choisir: soit API agent-friendly directe, soit enveloppe uniforme. Aujourd’hui v"; Decision criterion: "il faut traduire !"

### API and integration design
- Category: Software architecture
- Problem treated: Systems need a better way to talk to each other without creating fragile coupling.
- Entry signals: Endpoints are growing quickly; Integration decisions are slowing down delivery; The team needs a clear API shape before implementation
- Method: Design the integration path as a contract problem first; Minimize coupling between callers and implementations; Align API shape with the actual delivery flow
- Deliverables: API design notes; Integration path recommendations; Coupling risk summary
- Tools used: curl
- Inputs required: Existing API shape; Systems to connect; Integration constraints
- Exclusions: Endpoint sprawl without contract discipline; Integration work with no interface review
- Protocol preview:
  - Goal: Systems need a better way to talk to each other without creating fragile coupling.
  - Intake questions: What is the current existing API shape?; What is the current systems to connect?; What is the current integration constraints?
  - Core steps: Clarify the context; Find the main friction; Frame the next decisions; Prepare the delivery path
  - Guardrails: Endpoint sprawl without contract discipline; Integration work with no interface review
- Evidence examples: 15 files touched in lib/a2a (48.4% of 31 files); 15 files touched in lib/a2a (57.7% of 26 files); 5 files touched in lib/ai (27.8% of 18 files)

### Edge infrastructure delivery
- Category: Infrastructure
- Problem treated: Product delivery depends on infrastructure that must stay close to the edge and reliable under pressure.
- Entry signals: Edge deployment or worker behavior matters to the product; Infrastructure decisions are part of the delivery path; The system needs operational reliability at the edge
- Method: Treat infrastructure as part of the product path; Keep deployment and runtime behavior easy to reason about; Reduce operational surprises before widening usage
- Deliverables: Edge delivery plan; Operational risk notes; Deployment recommendations
- Tools used: docker; vercel
- Inputs required: Runtime environment; Deployment constraints; Operational pain points
- Exclusions: Infrastructure work disconnected from the product flow; Operational changes without delivery context
- Protocol preview:
  - Goal: Product delivery depends on infrastructure that must stay close to the edge and reliable under pressure.
  - Intake questions: What is the current runtime environment?; What is the current deployment constraints?; What is the current operational pain points?
  - Core steps: Clarify the context; Find the main friction; Frame the next decisions; Prepare the delivery path
  - Guardrails: Infrastructure work disconnected from the product flow; Operational changes without delivery context
- Evidence examples: 6 files touched in relay-worker (19.4% of 31 files); 5 files touched in relay-worker (19.2% of 26 files)

### Technical research and benchmark framing
- Category: Consulting
- Problem treated: A decision needs outside references, comparisons, or fresh technical research before the team can commit with confidence.
- Entry signals: The team needs a clearer comparison between options; Fresh technical research matters to the decision; Benchmarking can reduce uncertainty before commitment; Observed pattern: Competitive Intelligence; You learn by comparing what already exists
- Method: Competitive Intelligence — You learn by comparing what already exists; Use research to narrow the decision, not to postpone it indefinitely; Compare options on the dimensions that actually matter; Translate findings into a recommendation the team can act on
- Deliverables: Research brief; Benchmark comparison; Recommendation with tradeoffs
- Inputs required: Decision context; Candidate options or reference points; Constraints that matter to the choice
- Exclusions: Open-ended research with no decision attached; Benchmarking that never turns into a recommendation
- Protocol preview:
  - Goal: A decision needs outside references, comparisons, or fresh technical research before the team can commit with confidence.
  - Intake questions: What is the current decision context?; What is the current candidate options or reference points?; What is the current constraints that matter to the choice?
  - Core steps: Clarify the context; Find the main friction; Frame the next decisions; Prepare the delivery path
  - Guardrails: Open-ended research with no decision attached; Benchmarking that never turns into a recommendation
- Evidence examples: WebSearch detected 16/221 times (7.2%); WebSearch detected 3/55 times (5.5%)

### Product velocity slowdown diagnosis
- Category: Product management
- Problem treated: The team is shipping, but the time from idea to release keeps stretching.
- Entry signals: Cycle time keeps growing; Features spend too long in scoping or handoff; Squads are active but delivery still feels slow; The path from request to release has too many steps
- Method: Trace the path from request to release instead of discussing the issue abstractly; Separate product latency, execution latency, and decision latency; Identify where scope, ownership, or approvals create drag
- Deliverables: Prioritized bottleneck diagnosis; Friction map across product, tech, and delivery; Action plan to reduce time-to-market
- Tools used: google-analytics
- Inputs required: Recent feature examples; Team or squad map; Current delivery path; Known blockers and irritants
- Exclusions: Full organizational redesign; Pure infrastructure audit; Generic brainstorming without delivery evidence
- Protocol preview:
  - Goal: Find where product delivery slows down before suggesting how to speed it up.
  - Intake questions: What is the current recent feature examples?; What is the current team or squad map?; What is the current current delivery path?; What is the current known blockers and irritants?
  - Core steps: Rebuild the current path; Locate the main bottlenecks; Separate flow, decision, and ownership issues; Prioritize the first fixes
  - Guardrails: Full organizational redesign; Pure infrastructure audit; Generic brainstorming without delivery evidence
- Evidence examples: The signal behind Functional specification and scoping appears repeatedly in your sessions. It is not just a topic you touch once. It shows up as a repeated working habit

### AI agent orchestration and delegation
- Category: Consulting
- Problem treated: The work needs to be split between human judgment and agent execution without losing control of the outcome.
- Entry signals: The request can be decomposed into agent-friendly tasks; Delegation matters as much as direct execution; The system needs supervision, not just output
- Method: Divide the work into clear agent and human responsibilities; Use the agent for structure, preparation, and repetition; Keep final judgment in the human loop
- Deliverables: Delegation plan; Agent work structure; Human review points
- Inputs required: Task breakdown; Decision owner; Review checkpoints
- Exclusions: Fully autonomous delivery with no review; Delegation without a supervision model
- Protocol preview:
  - Goal: The work needs to be split between human judgment and agent execution without losing control of the outcome.
  - Intake questions: What is the current task breakdown?; What is the current decision owner?; What is the current review checkpoints?
  - Core steps: Clarify the context; Find the main friction; Frame the next decisions; Prepare the delivery path
  - Guardrails: Fully autonomous delivery with no review; Delegation without a supervision model
- Evidence examples: Agent detected 23/587 times (3.9%); Agent detected 3/221 times (1.4%)

### Product service design
- Category: Product management
- Problem treated: The product needs a clearer service shape, often around conversation, workflow, or guided agent interactions.
- Entry signals: The product feels too open-ended to use well; Users need a guided sequence, not just a feature; The interaction model needs to be clarified before implementation
- Method: Translate the interaction into a service shape that can be reasoned about; Clarify the decision points before implementation starts; Keep the user journey and the agent journey aligned
- Deliverables: Service shape proposal; Interaction flow summary; Implementation guardrails
- Tools used: google-analytics
- Inputs required: Target user journey; Required interaction steps; Constraints on the service shape
- Exclusions: Generic chat product design; Open-ended experimentation without a service boundary
- Protocol preview:
  - Goal: Give the product a clearer service shape before implementation starts.
  - Intake questions: What is the current target user journey?; What is the current required interaction steps?; What is the current constraints on the service shape?
  - Core steps: Clarify the service boundary; Turn the interaction into a guided path; Name the decisions and guardrails; Prepare the implementation frame
  - Guardrails: Generic chat product design; Open-ended experimentation without a service boundary
- Evidence examples: 2 files touched in app/(chat) (10.5% of 19 files); 4 files touched in lib/competency (14.8% of 27 files); 3 files touched in lib/competency (10.7% of 28 files)

## Strengths

- Version control strategy
- Technical audit and code review
- Technical workflow automation

## Areas of growth

- Feature sprawl
- Git hygiene under pressure

## Supporting competencies

### Full stack development (12 services)

#### Code refactoring and modernization [expert]
Evidence: Edit detected 170/587 times (29.0%). Edit detected 4/15 times (26.7%). Edit detected 27/59 times (45.8%).

#### API development and integration [proficient]
Evidence: 2 files touched in app/api (11.1% of 18 files). 2 files touched in app/api (10.5% of 19 files). WebFetch detected 38/38 times (100.0%).

#### Generative interface design [proficient]
Evidence: 3 files touched in lib/generative-ui (15.8% of 19 files). 12 files touched in lib/generative-ui (63.2% of 19 files). 4 files touched in lib/generative-ui (19.0% of 21 files).

#### Frontend development (React, Next.js) [proficient]
Evidence: 2 files touched in components/ (10.5% of 19 files). 4 files touched in components/ (19.0% of 21 files). 3 files touched in components/ (15.8% of 19 files).

#### Test-driven delivery [proficient]
Evidence: Decision criteria: Decision criterion: "il faut sortir de la boucle d’édition et lancer un test structuré"; Decision criterion: "il faut adapter ou compléter le @.claude/SPEC_28_First_Train_on_the_Rails.md ?"; Decision criterion: "il faut adapter ou compléter le SPEC_28?" — Asking about updating SPEC_28 documentation.". Avoids: Anti-pattern: "Never modify schema without written spec") instead of additional skills."; Anti-pattern: "never builds without a plan document first. Across Temet (SPEC_10 through SPEC_27), Pr"; Anti-pattern: "never imported elsewhere. Check `lib/` files especially.".

#### Frontend component architecture [proficient]
Evidence: Decision criteria: Decision criterion: "il faut choisir: soit API agent-friendly directe, soit enveloppe uniforme. Aujourd’hui v"; Decision criterion: "il faut traduire !". Avoids: Anti-pattern: "never replaces patterns, never recomputes loops, and never saves or re-renders anythin"; Anti-pattern: "jamais validés en fraîcheur ni unicité; puis chaque POST incrémente version et intervie".

#### Code standards and quality [proficient]
Evidence: Decision criteria: Decision criterion: "Il faut un format stable, agent-friendly, versionné, avec les champs les plus utiles en "; Decision criterion: "toujours juste 2 traces = recurring, 3+ = stable_rule, sans condition sur distinctSession"; Decision criterion: "always re-establishes context first."; Decision criterion: "ALWAYS returns `specFormat: "json_render_native"` for all paths (native success, native"; Decision criterion: "il faut un brief exécutable clair :". Avoids: Anti-pattern: "never jumps straight into coding. He always re-establishes context first."; Anti-pattern: "jamais claude opus", "pas d'anglicisme". Uses memory/save-state commands. Most notably,".

#### Data modeling and schema design [proficient]
Evidence: Avoids: Anti-pattern: "NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, ".

#### API design and specification [proficient]
Evidence: Decision criteria: Decision criterion: "il faut rendre plus rapide ! mais c'est noirmal d'avoir les 2 ici ?                     "; Decision criterion: "always restart — conflicts with manual stop), `false` (no auto-restart on crash), `{ Su". Avoids: Anti-pattern: "Never imported or routed to"; Anti-pattern: "never called from the frontend — check `app/api/` and search for fetch calls"; Anti-pattern: "jamais utiliser de anthropic api key, car on ne va jamais demander cela à l'utilisateur".

#### Database design and optimization [competent]
Evidence: 3 files touched in lib/db (16.7% of 18 files). 4 files touched in lib/db (40.0% of 10 files). 3 files touched in lib/db (14.3% of 21 files).

#### Feature development [competent]
Evidence: Write detected 29/587 times (4.9%). Write detected 6/400 times (1.5%). Write detected 6/319 times (1.9%).

#### UI/UX design and prototyping [competent]

### Software architecture (8 services)

#### Technical audit and code review [expert]
Evidence: Read detected 17/35 times (48.6%). Read detected 15/21 times (71.4%). Read detected 15/24 times (62.5%).

#### Legacy code analysis [proficient]
Evidence: Grep detected 10/35 times (28.6%). Glob detected 4/35 times (11.4%). Glob detected 5/21 times (23.8%).

#### AI product integration [proficient]
Evidence: 5 files touched in lib/ai (27.8% of 18 files). 3 files touched in lib/ai (15.8% of 19 files). 3 files touched in lib/ai (14.3% of 21 files).

#### Agent integration and protocol design [proficient]
Evidence: 15 files touched in lib/a2a (48.4% of 31 files). 15 files touched in lib/a2a (57.7% of 26 files). 2 files touched in lib/a2a (6.7% of 30 files).

#### Error handling and resilience [proficient]
Evidence: Decision criteria: Decision criterion: "always KV-based, handled in Worker)"; Decision criterion: "Il faut déployr pour résoudre ce bug ? Application error: a server-side exception has oc". Avoids: Anti-pattern: "Never expose internal error details in client-facing responses"; Anti-pattern: "Never expose internal error details to client"".

#### Security review and hardening [proficient]
Evidence: Decision criteria: Decision criterion: "toujours author-profile-hover-card.tsx"; Decision criterion: "il faut changer le cli ? cela me  parait consommer énormément de tokens... on était rest". Avoids: Anti-pattern: "JAMAIS ECRIRE "Co-Authored-By: Claude Opus 4.6" ! revert le commit et le push ?"; Anti-pattern: "never explains how the publisher authorizes a follower. Right now “follow by address a"; Anti-pattern: "jamais -- un token compromis reste valide indefiniment".

#### Software architecture and system design [competent]

#### Performance optimization [competent]

### Infrastructure (5 services)

#### Technical workflow automation [expert]
Evidence: Bash detected 4/35 times (11.4%). Bash detected 4/24 times (16.7%). Bash detected 27/46 times (58.7%).

#### Version control strategy [expert]
Evidence: 5 git commands out of 30 total tool calls (16.7%). 46 git commands out of 587 total tool calls (7.8%). 5 git commands out of 37 total tool calls (13.5%). Decision criteria: Decision criterion: "il faut absolument corriger l’idempotence de l’injection et rendre le prompt de deep ana"; Decision criterion: "il faut préciser "IA" ou "AI quelque part ! sinon on comprend pas"; Decision criterion: "Toujours planifier avant de produireen cours". Avoids: Anti-pattern: "jamais propagé au narrateur"; Anti-pattern: "never > always > preference patterns, defaults to "correction"".

#### Edge infrastructure delivery [proficient]
Evidence: 6 files touched in relay-worker (19.4% of 31 files). 5 files touched in relay-worker (19.2% of 26 files). 2 files touched in relay-worker (6.7% of 30 files).

#### Build automation and tooling [competent]
Evidence: 3 files touched in scripts (7.0% of 43 files). 3 files touched in scripts (13.0% of 23 files). 3 files touched in scripts (7.3% of 41 files).

#### Continuous delivery pipeline [competent]
Evidence: 2 files touched in .github (7.7% of 26 files). 6 files touched in .github (9.2% of 65 files). 2 files touched in .github (6.1% of 33 files).

### Product management (4 services)

#### Functional specification and scoping [expert]

#### Rapid prototyping and iteration [expert]

#### Conversational product architecture [competent]
Evidence: 2 files touched in app/(chat) (10.5% of 19 files). 4 files touched in app/(chat) (9.8% of 41 files). 3 files touched in app/(chat) (10.7% of 28 files).

#### Skill modeling and structuring [competent]
Evidence: 4 files touched in lib/competency (14.8% of 27 files). 3 files touched in lib/competency (10.7% of 28 files). 5 files touched in lib/competency (17.9% of 28 files).

### Consulting (4 services)

#### Technical research and benchmarking [expert]
Evidence: WebSearch detected 3/55 times (5.5%). WebSearch detected 7/36 times (19.4%). WebSearch detected 4/8 times (50.0%).

#### Technical decision-making under ambiguity [proficient]
Evidence: Decision criteria: Decision criterion: "we should copy into Temet?"; Decision criterion: "il faut mettre une timeline et des clics et des nouveautés comme dans l'exemple Temet dé"; Decision criterion: "il faut un chiffre : Moins de corrections à chaque session"; Decision criterion: "Il faut réorienter mes postes et réponses pas juste sur ce que vent temet, sur sur mes c"; Decision criterion: "always double checking any Claude implementation, with Codex 5.4, it always finds bugs,". Avoids: Anti-pattern: "jamais stocké systématiquement — les Decision Traces. Le pourquoi derrière chaque décis"; Anti-pattern: "Never bump without explicit request.".

#### Technical decision-making [competent]

#### AI agent orchestration [competent]
Evidence: Agent detected 23/587 times (3.9%). Agent detected 5/30 times (16.7%). Agent detected 13/400 times (3.3%).

### Content strategy (1 services)

#### Content strategy and editorial structuring [competent]
Evidence: 4 files touched in content (9.3% of 43 files). 3 files touched in content (13.0% of 23 files). 2 files touched in content (8.7% of 23 files).

## Proof of work

- 1042 sessions analysed
- 35171 prompts
- 65243 tool calls
- 34 skills detected
- 6 cryptographic receipts
- Last published: 2026-04-14T21:29:22.891Z

## Tools and agents

Tools: brew, chrome-devtools, cloudflare-api, cloudflare-bindings, cloudflare-docs, cloudflare-observability, curl, docker, gh, git, google-analytics, node, npm, npx, playwright, pnpm, python, python3, swift, temet, twitter, uv, vercel, xcodebuild

## How to engage

To request a service from this professional:
1. Read the mission capabilities and choose the one that matches your problem
2. Send a structured request via the Temet relay
3. The practitioner's agent will produce a mission plan with work units, deliverables, risks, and pricing
4. Review, negotiate, accept

https://temetapp.com/a/22cd91b5de1fdc50

---
Generated by Temet. https://temetapp.com