Dev With AI
What changes in developers’ work

The clearest convergence concerns the shift in work. Brevo describes cross-repository contributions that increase demand for review. Dorra Bartaguiz questions the quality of generated tests. Florian Bruniaux addresses CI waiting, PR comprehension and correction loops. These perspectives complement one another: generation throughput can exceed verification and integration capacity.

Enlarge ↗

Business knowledge recurs as an input. At Brevo, it takes the form of a map of systems and their owners. In the 2 legacy accounts, it needs to be extracted from code, configuration and data, then discussed with experts. For Bathilde and Rémi, it also comes from users and commercial constraints. A list of coding conventions cannot replace this knowledge.

The speakers do not propose the same degree of autonomy. Brevo says human review remains systematic at the time of the talk, while considering reducing it. Alexandre describes an automated implementation pipeline, with human framing upstream. Saif retains domain validation of the documentation. Florian directs human attention according to change risk. These are contextual choices; they do not demonstrate that one regime suits every team.

A second convergence invites us to test the checking tools. A green test can miss a business-rule error; a review can suggest a bad fix; an evaluator can accept an incorrect implementation. Dorra, Florian and Jean-Louis each address part of this problem. The number of checks added therefore does not prove their effectiveness.

Enlarge ↗

📋 Program title (translated): Antigravity: agentic development, Google DeepMind style. Official program.

🎤 Speaker: Guillaume Laforge · Developer Advocate @ Google. Conference profile.

Guillaume presents Antigravity as an environment for managing projects and agentic conversations, with an agent management application, an IDE, a CLI and an SDK. He shows projects spanning several directories, worktrees to separate changes, and artifacts for reviewing a plan, a diff or a verification journey.

The examples give inspection of the work a visible place: commenting on a plan, requesting a revision, retaining screenshots or a navigation video, then examining changes. Recurring automations include tracking SDK changes and updating a conference program. An interactive visualization explores fonts for a pixel-art display.

He also describes specialized subagents, instructions, hooks and permissions. The point for daily work is how delegation and inspection of results fit together. The feature list remains an account of his demonstration, rather than a verification of product availability, versions or security guarantees.

In the closing questions, he recommends choosing an experimental project and using AI to learn. He describes requesting a security review, then explanations of the reported problems. His example connects the delivered result with developer learning, provided time is taken to ask questions.

Deck additions, October 16, 2026

The deck makes Antigravity’s boundaries more explicit: a project defines a filesystem and security scope, with allow, ask and deny rules and sandboxing. A plugin can bundle a manifest, MCP servers, hooks, skills, agents and rules. The proposed loop remains Plan, Act, Verify.

Two distinctions matter: IDE extensions provide the agent side panel but not the in-editor AI assistance described for the full IDE; the Python SDK is presented as official and the Java SDK as unofficial. The GitHub reviewer example grants read-only capabilities, denies the rest and requires structured output. These are capabilities described in the deck, without verification of current availability.

Official deck · Slides 4, 11, 25, 28, 40, 46–47.

Enlarge ↗

📋 Program title (translated): Software Factory: collaborative AI reinventing development at Brevo. Official program.

🎤 Speaker: Mickaël Arias · CTO @ Brevo. Conference profile.

🎤 Speaker: Maxence Bourquin · Engineering Manager @ Brevo. Conference profile.

The problem extends beyond an individual developer’s speed. A change may require several repositories and code owners who are busy elsewhere. Brevo opens contributions across teams while retaining code owners for final decisions. Know-how becomes a resource to transmit through skills and workflows.

The first product, the Feature Factory, offered a collaborative specification and implementation journey. Mickaël explains its adoption limits: an overly fixed flow, a new interface to learn and coverage limited to feature creation. The next version rests on 4 components described in the talk: systems and organizational context, shared know-how, an agent execution platform and an interaction agent.

The review demonstration follows an approved scope, assembles agents according to the changes and separates corrections from notes for the maintainer. The contributor can accept a correction or justify rejecting it. The maintainer then receives the points requiring judgment, including implementation choices and consistency across repositories.

The questions make the limits concrete. The speakers acknowledge review overload and errors when context is missing or describes an old architecture. Maxence reports that an agent denied access to context invented components. Keeping the map current remains work to organize; listening to Slack and meeting decisions is presented as a possibility, rather than an already qualified system.

Enlarge ↗

📋 Program title (translated): When AI makes velocity explode: time for Harness Engineering! Official program.

🎤 Speaker: Dorra Bartaguiz · CTO @ Arolla. Conference profile.

Dorra starts with a kata that calculates screening invitation dates, inspired by a coaching engagement. Its interest lies in the rules and edge cases: the base calculation, invalid dates, nonworking days and postponements. This is a development exercise described in the talk, not medical advice.

The agent claims to have reached the requested coverage, but Dorra reports a different measurement and finds defects in both code and tests. She uses mutation testing: deliberately changing program behavior, then checking whether tests detect the difference. This challenges the ability of assertions to protect expected behavior.

She then repeats the work through an explicit process: explore domain terms, break down the need, formulate examples, choose a testing strategy, automate scenarios and implement in small steps. TDD guides and checks the agent here. Knowledge previously passed between developers can be made explicit in skills.

The talk broadens to the product lifecycle: strategy and design upstream, observability, maintenance and usage feedback downstream. Equipping only development risks shifting waiting elsewhere. More autonomous agents also require stopping conditions for their loops.

Deck additions, October 16, 2026

The slides quantify the kata’s discrepancy: the agent claims 100% coverage, while Dorra measures 33% overall and 95% in the domain. The reported mutation score is 13.82%. These measures have different scopes: high domain coverage does not establish that assertions detect defects.

The second attempt starts with domain vocabulary, examples and decomposition, followed by acceptance, unit and end-to-end testing. The final slides extend the harness across the product lifecycle, from discovery to operations. Loop Engineering addresses infinite loops and stalled progress; the software factory combines those checks with human supervision.

Official deck · Slides 16, 19, 27–38, 48–58.

Enlarge ↗

📋 Program title (translated): Conversation Review: a guide to helping AI-native teams improve. Official program.

🎤 Speaker: Marek Kalnik · CTO, Group Partner @ Theodo. Conference profile.

Marek describes a possible loss of code review’s teaching function when changes grow large and developers accept results that are difficult to review. The operator’s work now includes framing, context, decisions and interactions with the agent. His framework makes that work available for discussion among colleagues.

The proposed checkpoints concern task size and nature, execution, validation, cost, human intervention and repeatability. He distinguishes execution delegation, where the objective is already clear, from a design exchange where questions and ideas need to circulate. Message count alone therefore cannot judge a conversation.

His example shows a request for technical strategy drifting into implementation. The tools and tests run afterward do not, on their own, answer the initial question. Reviewing the trace exposes this scope change, avoidable searches and decisions that should have returned to a human.

The discussion leads to changes to the working system: clarifying context, adding a targeted skill, improving a testing mechanism or reducing repeated corrections. The proposed aim is to improve how the team builds and directs agents. Conversation Review complements code validation; it does not prove correctness.

Deck additions, October 16, 2026

Conversation Review has an explicit three-part framework: Intent, for the approach to the task; Evidence, for what justifies accepting the result; and Control, for scope, context, tools, permissions and consequential decisions. This makes the review more specific than a general judgment about prompt quality.

The proposed ten-minute ritual uses one real session, examines one consequential step and selects one improvement. The deck also identifies Theodo Group’s coding-conversation-analyzer project. Suggested savings in the session example are analytical estimates, not measured gains after a correction.

Official deck · Slides 23, 34, 39.

Enlarge ↗

📋 Program title (translated): Modernizing a 30-year-old information system with an “Agentic Factory”. Official program.

🎤 Speaker: Alexandre Jeambrun · Senior Software Engineer @ Octo Technology. Conference profile.

Alexandre starts by reconstructing documentation, then discussing it with domain experts. A rule extracted from the system may no longer match the desired rule. The next steps rely on functional domains, specifications, architecture and user journeys. Code generation follows that definition work.

The pipeline includes a coordinator assigning tasks and agentic systems responsible for planning, implementing, reviewing, correcting and monitoring pipelines. Shared context needs to preserve consistency across projects. During review, agents examine standards, test strategy and security criteria; an additional pass verifies that reported problems exist before preparing corrections.

One design choice distinguishes this account: regenerating an isolated unit from specifications rather than repeatedly modifying its code. Alexandre connects this choice to modularization by use case, with stable input/output contracts. Contract stability is a condition of the approach described, not a guarantee that every regeneration is impact-free.

He also uses pull flow and work-in-progress limits. Microtasks can run in parallel, but merging needs protection from incoming concurrent changes. The control point lies as much in flow organization as in the agent writing code.

Deck additions, October 16, 2026

The deck gives the scale of the system under study: 33 million lines and 18 languages. Its architecture combines a coordinator with a UI and API, a task queue, a semantic Context Broker, specification and component repositories, and a pool of agents. The sequence moves from reverse documentation to specifications, backlog, Definition of Ready and an implementation plan, then review, correction, build and merge.

Review combines four parallel analyses: code quality, missing tests, test execution and security/compliance. An independent verifier then rereads the files and findings before producing the correction plan. The board illustrations show a work-in-progress limit of two items in the development column. That value belongs to the example; the deck establishes neither a universal limit nor completion of the entire modernization.

Official deck · Slides 3–9, 10–21.

Enlarge ↗

📋 Program title (translated): Code faster with AI, deliver better as a team: from code to merge. Official program.

🎤 Speaker: Florian Bruniaux · Founding Engineer / Harness Engineer @ Méthode Aristote. Conference profile.
Detailed talk guide, slides and examples: Du code au merge (French) · From code to merge (English).

Florian describes work accumulating between code production and delivery: waiting PRs, conflicts, human analysis, compute minutes and reruns. Finding an error early avoids repeating that work downstream. He presents moving checks to the developer’s workstation, with hardware constraints and costs to consider.

Enlarge ↗

A PR needs to be understandable to people and review agents. He describes seeking a balance between a short description, business rules, architecture, tests and collapsible technical details. Traceability of the model, skills and agents then supports replaying and improving the process.

Review combines CodeRabbit, FriendlyReviewer and an in-house reviewer evolving toward business rules. A step gathers feedback, groups duplicates and examines contradictions. Florian stresses the distinction between finding a defect and proposing the right correction. His missing-document and forbidden-access examples show why a suggested fix needs checking against expected behavior.

Human attention is directed toward changes considered sensitive, such as payments, access rights or private data. He acknowledges that this sorting can be wrong. Corrections need a stopping condition: objective reached, budget exhausted, iteration count, blocker or disagreement. CI also needs to distinguish an error found by a test from a check that could not run.

PR feedback becomes material for addressing the cause of a repeated error, adjusting the harness and replaying the case. The gains and costs mentioned remain those of his experience described orally; this report demonstrates neither reconciled savings nor a measured delivery gain.

Deck additions, October 16, 2026

The deck makes validation concrete: an interface change calls for DOM, click and mobile checks; a shared component can require an end-to-end path; an access rule must be checked for allowed and denied cases in both the UI and API. Review AI and Review Human labels route review according to risk without removing mandatory checks.

Reviewers should examine the same revision and base. Evidence for commit A does not validate commit B: inspect the delta and rerun the required checks. A skipped, cancelled or pending status is not success. A recurring defect becomes a root-cause issue with expected behavior, the source PR, a correction to the test or context, and another trial on other cases.

Official deck · Slides 10–12, 16–17.

Enlarge ↗

📋 Program title (translated): From completion to harness: 5 years of Dev with AI, from code to business. Official program.

🎤 Speaker: Tugdual Grall · Strategic AI GTM Lead @ GitHub. Conference profile.

🎤 Speaker: Xavier Noya · Senior Software Engineer @ Betclic. Conference profile.

Tugdual traces the move from completion to conversation, then to delegated tasks from a CLI or agent management application. Xavier connects this evolution to adoption at Betclic: IDE habits, discovering unfamiliar codebases and spreading new practices within the company.

Enlarge ↗

They invite a reassessment of instructions and skills as models and environments change. A practice useful yesterday can become redundant. They propose testing an agent with fewer layers, then rebuilding what addresses observed limitations. This does not establish that business constraints or authorizations have become unnecessary.

Xavier describes intensive experiments with specification-driven development frameworks. He reports fatigue from reading Markdown, approval requests and large PRs, eventually leading to mechanical acceptance. He retains the value of specification, but questions rigid sequences and questions that do not help a decision.

Tugdual describes a recurring benchmark on an application to compare models, contexts and skills. He prioritizes the cost of the result obtained over token volume alone. Xavier complements this with workshops and an internal guild for sharing experiments and improving adoption.

Deck additions, October 16, 2026

The deck names Spec Kit, OpenSpec, BMAD and AI-DLC to question their value and overhead relative to the actual need for planning and architecture. It asks teams to adapt the level of method to the task. This is not a quantitative ranking and does not support a blanket rejection of those frameworks.

Other additions concern collective learning through workshops and shared practices, environments that support parallel agents, and a flow from a Slack exchange or meeting to an issue and then a PR for review. Context includes memory, instructions and tools.

Official deck · Slides 4, 6–9.

Enlarge ↗

📋 Program title (translated): The token war: advanced techniques to divide your LLM bill by 3. Official program.

🎤 Speaker: Philippe Prados · IA Leader @ Carbon IT. Conference profile.

Philippe connects an agent’s bill to its number of turns, reused context and the quality of available operations. His material distinguishes fixed context, generation and tool results. Shortening a final response therefore addresses only part of the agent’s work.

Enlarge ↗

For context, Philippe distinguishes the tool catalog from descriptions and schemas actually retrieved: he describes a deferred tool search step. He recommends choosing useful MCP servers before the conversation and keeping skill descriptions short. Read the material and diagram with that distinction, rather than as evidence that every installed tool is fully injected on every turn.

Personal preferences belong in user instructions; project constraints belong in its local instructions. Specialized rules can depend on file type. Philippe also proposes shared project memory to avoid reconstructing the same searches or knowledge. He acknowledges its cost and does not present one memory strategy as superior to all others.

For generation, he recommends adjusting the model, reasoning effort and response style separately. Concise output targets visible tokens; it does not directly control internal reasoning. The article proposes testing a capable model at low effort, without a benchmark here establishing general superiority.

For tools, the objective is a complete operation with a usable result. Examples include IDE or LSP symbol search and renaming, targeted and grouped edits, calculations delegated to a program, and output compression with RTK or similar tools, while retaining access to missing details.

For loops, he proposes grouping operations, automating formatting and intervening when an agent drifts. Returning to the initial prompt with missing constraints is one way to avoid accumulated corrections. That advice requires preserving useful results and checking the new process on the task concerned.

Philippe connects prefix stability to cache reuse, using an example of a changing timestamp at the start of a prompt. His simulator examines amortizing compaction. Compacting after a pause is presented as an option if the cache has actually expired and subsequent exchanges can amortize the operation. Anthropic still bills cache reads and writes. Anthropic prompt caching documentation.

At the end of the conference, he describes a rebuildable configuration: a dedicated configuration project, instruction fragments and installation scripts for several clients. The stated aim is to recover a clean environment after experiments and avoid leftover components. This report describes that organization; it does not validate the compression tool mentioned.

Enlarge ↗

📋 Program title (translated): Software archaeology in the AI era. Official program.

🎤 Speaker: Saif Jerbi · Tech Lead @ TotalEnergies Digital Factory. Conference profile.

Saif describes an old refinery system whose knowledge disperses as experts leave or change teams. Code represents only part of its behavior: scheduled jobs and configuration also contain rules. An automatic translation that compiles can therefore miss what the system should do.

Enlarge ↗

His process separates legacy analysis, documentation generation in a format experts can use, and code generation. Knowledge is shared between developers and agent sessions. Experts validate and correct the documents before implementation, within a scope the team can absorb.

He reports a limitation of this documentation: it does not always expose every case. The generator can return to authorized code and configuration when information is missing. Execution history and legacy outputs provide material for comparison tests. Examining longer periods reveals cases invisible in an initial sample.

Saif also describes separating access to company code and a vendor’s code, following an internal contract review. MCP interfaces govern access to APIs and data. This is an account of his project’s setup; this document draws no legal conclusion about other software or the sufficiency of those controls.

Deck additions, October 16, 2026

The ZIP contains light and dark editions of the same deck. The case describes roughly two million lines of PL/SQL, more than 200 packages and 200 jobs. Its tools combine Claude Code, MCP access to legacy APIs and the database, RTK and LikeC4.

The workflow separates three responsibilities: reconstruct documentation and rules from accessible sources; have experts correct and validate that scope in Confluence; generate Python and compare its behavior with historical data. Examples include off-peak hours, daylight-saving changes and inactive meters. Extending the history from three months to six months and then a year helps reveal cases missing from the first sample. Outcomes and durations remain those of the reported experience, without extrapolation to a complete migration.

Official deck · HTML: architecture, workflow, continuous improvement.

Enlarge ↗

📋 Program title (translated): Are our agentic workflows really improving? Official program.

🎤 Speaker: Jean-Louis Rigau · Vibe coder & AI-native advisor @ Manufacture. Conference profile.

Jean-Louis starts with an experimental question: does adding a skill, a review or a new model improve the result on a given task? He proposes defining success before experiments, recording runs and comparing quality, cost and repeatability. Comparisons should concern your own tasks, rather than public rankings alone.

Enlarge ↗

The example application manages contracts. The case adds a clause library with a requirement for no duplicates on retry. The report describes 19 acceptance criteria and 60 runs. The deck retrieved on October 16 confirms 3 models, 4 workflows and 5 repetitions for protocol r07a. Configurations distinguish the agent alone, an added skill, a review followed by correction, and their combination.

The results presented show limited or configuration-dependent contributions. A skill can encourage testing the right case while producing an incorrect expected result. A review can miss a defect if it does not know where to look. In another study, an installed workflow is not always executed, and forcing the full sequence can increase cost or cause a timeout. Jean-Louis himself stresses the small size of some series.

The second subject is evaluator quality. It can reject a correct solution or accept a defect. Jean-Louis describes a reference implementation, correct variants, deliberate errors, mutation testing and critiques from other models. He retains traces and compares evaluator versions on the same outputs, rather than removing earlier verdicts.

He shows a history view stuck after a loading error, missed by one version and detected by the next. The apparent ranking then changes without a new implementation. Infrastructure incidents also need identifying to understand what a score measures. The talk’s message is to reassess a workflow after a model or task change and test its measurement instruments.

Deck additions, October 16, 2026

The r07a protocol is now explicit: 3 models × 4 workflows × 5 repetitions, yielding 60 results against 19 criteria. C0 is the agent alone, CB adds the skill, CR adds review and correction, and CBR combines both. The evaluator is deterministic, without an LLM. With evaluator v5, the Opus 5.5 row moves from 4/5 for C0 to 2/5 for CB; these small samples do not establish a general rule about skills.

A separate study, r08, contains 90 trials: 3 models × 3 configurations × 10. For Opus 5.5, the table reports 7/10 and $2.9 for baseline, 8/10 and $5.5 with Superpowers, and 10/10 and $13.5 with strict Superpowers. Task success and compliance with the full sequence are separate measures: the final configuration follows the entire workflow in 7 out of 10 cases. These results must not be mixed with r07a.

The v4/v5 comparison reevaluates the same candidates without regenerating them. It adds detection of a history view stuck after a loading error: apparent 5/5 results with and without the skill become 2/5 and 4/5 respectively. The deck also documents false rejections caused by an asterisk in a label. Freezing the protocol, retaining hashes and verdict versions, separating infrastructure incidents and testing the evaluator are therefore part of the experiment.

Official deck · Slides 7–14, 18–21.

Enlarge ↗

📋 Program title (translated): How I changed my app-building flow in 18 months. Official program.

🎤 Speaker: Bathilde Rocchia · iOS Developer @ Vivace App Studio. Conference profile.

Bathilde compares an initial app addressing sedentary behavior with a second, Ventilate, which helps choose when to open windows based on conditions. The shift starts with more testimonials and user feedback. Accumulated information becomes design and planning material in Markdown files.

AI contributes to mobile development, publication visuals and the website. Bathilde describes connecting Figma to her agent, while retaining manual adjustments for results she cannot obtain. For the site, she ultimately prefers Astro and repository-driven content to a CMS she was not using to publish.

She also reports a limit of social-media automation: automatic posts make her feel she is losing control of her project. Finding beta testers and making direct contact remain part of her work. This report preserves the distinction between accelerating production and obtaining feedback that guides the product.

Her conclusions concern the scope she understands and can automate, user interviews and the Git repository that collects knowledge. Beyond code, it contains feedback, decisions and distribution recommendations.

Deck additions, October 16, 2026

The deck specifies uses around the product: access to the Apple Ads API from Cursor and then Codex, store screenshot variants, edits in Figma and an Astro site backed by Markdown. AI contributes to distribution and presentation as well as application code.

Bathilde compares BreathInU and Ventilate: for Ventilate she reports three weeks of development, two stores and more than one thousand downloads in the launch month, versus more than a month, iOS only and roughly one hundred downloads for BreathInU. Products, platforms and launch conditions differ, so those figures do not measure a causal effect of AI. Her closing recommendations concern user research, a knowledge base in Git and automating work one understands.

Official deck · Slides 12–14, 17–22.

Enlarge ↗

📋 Program title (translated): HorseBrokers - an app built in a language I had never known. Official program.

🎤 Speaker: Rémi Lakmeche · CTPO @ The One Studio. Conference profile.

Rémi presents HorseBrokers as a product for sport-horse brokers. It centralizes horses, results and documents, supports searches based on a buyer’s needs and makes listings easier to share. The business problem comes from his field knowledge, then serves as the starting point for the project.

He describes solo development with BMAD and Claude Code on a mobile stack he had not mastered before. His project experience helps him define the brief, design, architecture, data-flow rules and stories before implementation. He delegates code while retaining framing and trade-offs.

His account stresses what he had to add: tests and pre-commit checks, staging and production environments, API versioning, security and load audits, and error and traffic monitoring. He says these practices were not supplied natively by the tool/method combination. Subagents parallelize implementation under coordination.

He says the MVP is live on iOS and Android, but describes prospecting as a separate difficulty. Showing the app to people he knows is not enough to reach customers. He describes direct conversations at competitions and events to obtain trials and sell the product. User counts, revenue and token volumes are not validated in this report.

Deck additions, October 16, 2026

The technical choice addresses a specific business constraint: equestrian competitions can have poor connectivity, hence offline operation with SQLite in the React Native/Expo application. The described backend uses Fastify and PostgreSQL with Drizzle; the deck also names Railway, R2 and Sentry.

The BMAD workflow moves through brief, PRD, architecture, epics, stories, code and tests. Rémi describes pre-commit and pre-push hooks, unit, integration, API and mobile tests, a staging environment and security audits for major changes. The 1,700 tests and other displayed volumes remain claims from the deck: their count establishes neither risk coverage nor assertion quality. This report does not verify total cost or commercial adoption.

Official deck · HTML: stack, workflow, quality, figures.

Enlarge ↗

📋 Program title (translated): rtk: from a Rust CLI with 80k stars to a startup generating revenue. Official program.

🎤 Speaker: Patrick Szymkowiak · CEO @ rtk-ai labs. Conference profile.

🔗 Explore the tools: RTK · RTK Pro.

The talk connects a command-output compression tool for coding agents, its open-source adoption and the development of RTK Pro.

Make value visible. Visible gains and community contributions support a tool’s spread. The takeaway is to let users see its benefit and share their uses. Reducing output sent to the model does not, by itself, demonstrate an equivalent reduction in the total bill.

Move from individual use to team needs. Cost attribution by project and developer, security policies, and distribution of practices and skills are among the needs discussed for RTK Pro. The aim is to make developer onboarding easier within a shared framework. These are positioning directions, rather than a product-effectiveness assessment.

Let users adapt the tool. One direction is to let users customize their filters and share their uses rather than trying to anticipate every need. This complements the discussion of agent harnesses and context selection.

Deck additions, October 16, 2026

The claimed 60–90% reduction concerns command output. It does not directly represent the same saving across the whole context or bill. Binary downloads and GitHub stars do not count unique active users; logos derived from stargazers’ organizations do not establish commercial relationships.

The deck distinguishes the available CLI, rtk-engine presented as an unreleased beta, and RTK Pro features at different stages. The proposed chain covers hooks, filtering, routing and policies. The stated scope of some checks also varies by integration, notably between Claude Code and MCP results alone in Cursor. Forthcoming features and shared memory under review remain announcements from the deck, not capabilities tested here.

Official deck · Slides 6–13, 17, 20–21.

Enlarge ↗

📋 Program title (translated): Building applications for humans and agents. Official program.

🎤 Speaker: Katia Gil Guzman · Developer Experience @ OpenAI. Conference profile.

Announced topic: consider AI agents a new kind of user. The description invites a reassessment of software design and interactions so that humans and agents can collaborate inside applications.

Deck additions, October 16, 2026

The deck now extends the announced topic with three concrete mechanisms. Extensions add entry points, interactive panels and file viewers. WebMCP exposes application actions to an agent from the open page, reusing application logic and the signed-in session’s permissions. Annotations connect an interface selection to the user’s intent and the context sent to the agent.

Examples include Aisle for a seating plan and pinned seats, ArchMorph for a shared 2D/3D home representation, and JupyterLite for unsaved cells and a shared kernel. The aim is to expose useful application state and relevant actions while retaining an interface for the human.

The final slides connect Sites, WebMCP, annotations, MCP servers and MCP Apps interfaces. This account describes the mechanisms and demonstrations in the deck; it does not certify the current availability of each API or its behavior in a deployed application.

Official deck · Slides 8, 10–13, 15–16.

Greg announced Dev With AI training. The official catalog lists two one-day courses:

Developing with Claude Code: the foundations, with Aurélien Binder-Meunier: configure your agent, document your project, delegate code and verify the result. Next online session: November 23, 2026.

Industrializing your workflow with Claude Code, with Florian Bruniaux: organize review and correction, automate checks and track the cost of accepted results. Next online session: November 24, 2026.

Two formats are offered: cross-company online sessions on fixed dates, or training for a team, on site or remotely, adapted to its context.

Enlarge ↗

1. Choose a change and define success

   Set expected behaviors, edge cases and checks before adjusting the workflow. Keep those criteria throughout the comparison. Include business effects, rather than compilation alone.

2. Compare a minimal harness with the current configuration

   Replay a comparable task with and without a specific layer, such as a skill or an extra review. Record what actually ran, outputs, failures, costs and human interventions. Repeat to observe variability.

3. Review a conversation and review feedback

   Recover the initial intent, drift, avoidable searches and decisions. Check findings against the code and business rules before accepting a fix. Choose a repeated cause to address in the system.

4. Test the checking instruments

   Introduce a known defect and a correct variant. Verify that tests or the evaluator distinguish the 2. Keep evaluator-version verdicts separate and identify infrastructure incidents.

5. Verify use and delivery

   For legacy software, compare historical outputs over periods covering the selected cases and have an expert validate the rules. For a product, obtain feedback from its users. Track review waiting, rework and post-delivery outcomes before attributing a gain to generation.

These experiments require a chosen scope and retained evidence. Their results depend on the task and the team’s context.

The roles below are those listed for the conference. LinkedIn links come from the official website, without searching for people with matching names. The LinkedIn profiles themselves were not opened.

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

Enlarge ↗

The content committee prepares the program by selecting speakers and topics. The official website presents 3 profiles spanning startups, IT services companies and large technology groups.

Marek Kalnik, Group Partner at Theodo and former CTO, supports technical teams and their organization. His topics include software craftsmanship, technical leadership and AI’s effects on developers’ work.

Laetitia Lanfranchi, an engineer and entrepreneur, supports agentic workflow adoption, legacy modernization and AI-assisted product development through BotBloom.

Arthur Magne, cofounder and CTPO of Packmind, works on knowledge sharing between developers and AI agents, with a particular interest in Context Engineering.

Summary based on the official committee section, consulted on October 13, 2026.

Enlarge ↗

Thank you, Greg, for organizing this first Dev With AI edition and bringing the community together around concrete practitioner accounts!

Learning and meeting people: the 2 objectives you give the conference also set the tone for this recap. Thank you for the work that keeps Dev With AI and developer meetups going.

To continue the conversations: the Dev With AI community, its Slack and the announced training courses.

Conclusion

The talks describe practices for generation, collaboration, verification and product development. To test them within your team, choose a measurable case, test the checks and retain domain feedback.

Useful links

• Official Dev With AI program · October 13, 2026 · Verified observation
• CARBON article: The token war · October 12, 2026 · Documentary source
• Philippe Prados: Optimizing tokens, conference video · October 13, 2026 · Documentary source
• Anthropic documentation: prompt caching · October 13, 2026 · Verified observation
• Dev With AI training · October 13, 2026 · Verified observation
• Speakers and their LinkedIn profiles · October 13, 2026 · Verified observation
• RTK: official website · October 13, 2026 · Documentary source
• RTK Pro: official website · October 13, 2026 · Documentary source