Hari Krishnan
Author of "Spec-Driven Development: Engineering with intent" (Manning), Intent-Driven.Dev
Bengaluru, India
Actions
Hari Krishnan is the author of Spec-Driven Development: Engineering with Intent (https://www.manning.com/books/spec-driven-development), currently available through Manning’s MEAP. He has published an InfoQ article on enterprise adoption of Spec-Driven Development (https://www.infoq.com/articles/enterprise-spec-driven-development/) and serves as a maintainer (Technical Direction Advisor) to OpenSpec (https://github.com/Fission-AI/openspec). He is also the creator of Intent-Driven Dev (https://intent-driven.dev/).
Hari is the Founder and CEO of Polarizer Technologies (https://polarizer.in/), where he helps teams build AI-native products and adopt AI-augmented development practices at scale. He has over two decades of experience across finance, telecom, logistics, and retail, and has led enterprise-wide initiatives in architecture, developer experience, test automation, and AI adoption.
Hari has spoken at several international conferences and actively contributes to open-source projects. His current areas of interest include AI-native software engineering, Intent-Driven Development, Context Engineering and Harness Engineering.
Links
Area of Expertise
Topics
Spec-Driven Development: Can You Ship Without Reading the Code?
Writing a spec and having a coding agent follow it to generate an implementation is the easy part. But if we still have to read every line of generated code to determine whether it matches the spec, we have realized only part of the benefit of Spec-Driven Development. We may have improved our own clarity by articulating our intent through the spec. But can we trust the implementation to be aligned with it?
The harder problem is building a harness that keeps the specification and implementation aligned. When the agent gets something wrong, our first instinct is often to fix the code. Instead, we can ask a more interesting question. What gap in the spec did the implementation expose? When the same kinds of gaps keep appearing across specs, we go one level higher. We can ask what needs to change in the harness to help us better articulate, review, and refine our intent (https://intent-driven.dev/assets/blog/intent-harness/harness-feedback-loop.jpg).
In this talk, we will use practical coding-agent demonstrations to show how gaps in the implementation can be traced back to the spec. We will then trace them further back to the SDD workflow or harness that failed to ensure spec completeness. The real test of an SDD harness is whether we can eventually trust the resulting implementation enough to ship it without reading the code.
Spec-Driven Development: A Pragmatic Look
Spec-Driven Development (SDD) has quickly moved from being an experimental workflow to something many teams are now exploring seriously. The idea of expressing intent through a specification and letting tools and agents use that to plan, generate, and validate work sounds appealing, but fitting it into the realities of day-to-day engineering is a different story.
In this talk, we’ll take a grounded look at how SDD can coexist with the messy realities of modern software teams. Where do features live? In your project board, or inside the codebase? What if you do not have a monorepo? How do you balance evolving specs with distributed ownership and asynchronous delivery? In fact a more fundamental question being what is even a spec and the mixed use of jargon like PRD.
Drawing on examples from my work and the broader Spec-Driven ecosystem (OpenSpec, Spec-Kit, and similar tooling), we will explore what is working, where it is met with friction, and where SDD actually adds value. This is not a tutorial or a pitch for the approach itself. It is an attempt to map the principles of SDD onto the practical rhythms of product engineering, design, and AI-assisted implementation.
If you have been curious about SDD but unsure how it fits into your team’s structure, this session will give you a realistic lens to evaluate and adopt it at your own pace.
Learning Outcomes
1. What Spec-Driven Development is and how it compares? contrasting SDD with vibe coding and plan-mode workflows, and understanding different levels of spec-driven development
2. Is SDD only for Greenfield? or does it work for Brownfield and if yes how?
3. Understanding the ecosystem, tooling and their philosophy to categorise and chose one that aligns with your thought process
4. What Spec-Driven Development looks like in practice - across different team and code repo structures.
5. How big should a feature be for SDD? What limits can you hit?
6. Avoiding token drain generating Markdown Mountains
7. What SDD does not replace? and the basic skills that help extract the most out of SDD
8. Ecosystem overview, aspects to consider while choosing tools and approaches
My InfoQ article - https://www.infoq.com/articles/enterprise-spec-driven-development/
Supercharging Spec-Driven Development for Event-Driven Architectures with AsyncAPI
Spec-Driven Development (SDD) has been steadily gaining traction (popularised by Kiro, GitHub Spec Kit, etc.) for its ability to articulate and break down a feature into well-thought-through, detailed tasks for AI coding agents to implement.
When building Event-Driven Architectures (EDA) using SDD, the process can be hindered by the ambiguity of plain-language markdown and the absence of a concrete system representation. This is where the AsyncAPI specification becomes a powerful companion.
AsyncAPI brings precision and structure to what would otherwise remain loosely defined. It allows teams to externalise their intent into a clear, machine-readable design artifact that describes channels, messages, and bindings. This effectively clarifies the architecture before implementation begins. The result is a system design that is both reviewable by humans and directly usable by AI coding agents as a source of truth for building out the implementation.
If you are interested in learning how a pragmatic approach to Spec-Driven Development can be applied to building event-driven systems (without the hype), and with AsyncAPI as the bridge between design intent and working code, this session will offer a concise, experience-based walkthrough.
Intent Articulation Is Your Bottleneck, Not Token Budget
Coding agents and their underlying models are becoming more capable, with larger context windows. These advances should allow us to get out of the agent’s way and let it build independently. But that only works if what it builds is what we intended. Larger context windows do not make structured context less important. If anything, poorly articulated intent can allow an increasingly capable agent to travel further in the wrong direction before we intervene. The result is more clarification, review, correction, and potentially expensive rework. The bottleneck is our ability to articulate intent clearly and provide the right context so that agent-generated implementations stay aligned with our goals.
Every time we leave something unstated, ambiguous, or disconnected from the context available to an agent, we leave room for interpretation. Intent-Driven Development is about engineering this interpretation gap towards zero. In this talk, we will build a harness around this principle. We will use techniques such as Spec-Driven Development and iterative loops to articulate and refine intent. We will structure context so that agents can navigate relationships between requirements, decisions, terminology, constraints, and implementation. We will use artifacts such as ADRs and glossaries to preserve important context and make the necessary information available when the agent needs it, rather than putting everything into the context window upfront. Most importantly, we will use feedback from agent execution to detect where interpretation entered the system and continuously improve the harness to prevent the same deviations from recurring.
The goal is to move towards a software factory where we do not have to constantly supervise agents to keep them on track. We engineer and continuously tune the system so that the software produced by the harness converges towards what we intended. The less we leave open to interpretation, the more autonomy we can safely give the agent.
DeveloperWeek 2026 Sessionize Event
API Days India
AsyncAPI 2.6 to 3.0: Migrating Safely with No-Code Backward Compatibility Checks
GOTO Serverless
Reliable AWS Lambda Data Pipelines with AsyncAPI Specification
https://conferences.gotopia.tech/goto-serverless-bengaluru-2025/sessions/3845/reliable-aws-lambda-data-pipelines-with-asyncapi-specification
Video - https://www.youtube.com/watch?v=3McRayR31D4
APIDays New York
Using GraphQL SDL Files as Executable API Contracts - https://speakerdeck.com/harikrishnan83/using-graphql-sdl-files-as-executable-api-contracts
Unifying OpenAPI & AsyncAPI: Designing JSON Schemas + Examples for Reuse - https://speakerdeck.com/harikrishnan83/unifying-openapi-and-asyncapi-designing-json-schemas-plus-examples-for-reuse
Agile India 2025
API Design Anti-patterns: How to identify & avoid them - https://www.youtube.com/watch?v=U1Di4RyyG4w
DeveloperWeek 2025 Sessionize Event
Functional Conf 2025
The Functional Fix: Kotlin Error Handling Made Elegant - https://www.youtube.com/watch?v=byIcRxtk6gA
APIDays Paris
Contract-Driven Development for Event-Driven Architectures (https://conference.asyncapi.com/venue/Paris)
Slides - https://speakerdeck.com/harikrishnan83/contract-driven-development-for-event-driven-architectures
AsyncAPI Online Conference Edition
Using API spec as an Executable Contract To Mock and Test Microservices
Video - https://www.youtube.com/watch?v=wiM20HTCerM
Slides - https://speakerdeck.com/harikrishnan83/asyncapi-as-executable-contracts
AsyncAPI Conf On Tour 2023
Kafka and JMS Mocking with AsyncAPI using Specmatic
Video - https://youtu.be/9yRf75p_kTU?si=iR4lV_HLaVlUKsrY
AsyncAPI allows us to articulate communication channels between services clearly. What if I told you that this AsyncAPI specification is all it takes for us to quickly spin up mock topics and queues to test our services in isolation?
That is exactly what Specmatic is able to achieve by leveraging AsyncAPI specifications to give us early feedback on our local machines and in our CI pipelines when our service implementations deviate from the API specifications.
In this talk, I will be going over below points in detail:
1. Ability to detect deviation in implementation at a protocol, schema and more during early stages of development to shift left the identification of potential integration issues.
2. Leveraging AsyncAPI specifications to collaborate between teams to develop and deploy microservices in parallel with confidence.
3. How this ability fits into the overall concept of Contract Driven Development.
API World 2022 Sessionize Event
API Specifications Conference 2022
Turn Your OpenAPI Specifications into Executable Contracts
Event - https://sched.co/15pVN
Video - https://youtu.be/U5Agz-mvYIU?si=IbXcmiqrhuYOSLcU
Selenium Conf 2022
Contract Driven Development - Deploying your MicroServices independently without integration testing
TestingUy 2021 Sessionize Event
Agile 2021
Abstract / Teaser - https://vimeo.com/551960536
Video - https://www.youtube.com/watch?v=LaKhBS-_4p4
Hari Krishnan
Author of "Spec-Driven Development: Engineering with intent" (Manning), Intent-Driven.Dev
Bengaluru, India
Links
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top