Learning Reusable Reasoning for Reliable AI-Assisted Programming

I study how AI systems learn to reason about software and turn that reasoning into reliable programming behavior. Coding agents must understand existing code, identify necessary changes, investigate unsuccessful attempts, and assess whether their edits satisfy requirements without introducing regressions.

My research connects two directions: learning reusable reasoning for programming and building reliable coding agents. Formal verification provides one source of evidence, alongside execution, testing, static analysis, and human review.

Research direction 1

Learning reusable reasoning for programming

How can models learn reasoning strategies that transfer across programs and tasks?

Programming involves understanding behavior, identifying assumptions, decomposing problems, and revising hypotheses when evidence contradicts them. I would study how models acquire these capabilities from successful solutions, failed attempts, and tool feedback.

My hypothesis is that learning from reasoning decisions linked to their consequences supports better transfer than learning only from final solutions. For example, an agent could learn why a diagnostic input distinguishes competing explanations, or why an assertion helps establish a program property. The goal is to learn when to introduce an abstraction, gather evidence, revise a hypothesis, or change a decomposition.

Evaluation would distinguish retrieval, refinement during inference, and strategies learned through training. Comparisons would control information, tools, and computational resources, measuring accuracy, transfer, and total effort on unfamiliar programs and changed requirements. Loop-invariant revision provides an initial setting, followed by debugging, repair, and program understanding.

Research direction 2

Building reliable coding agents

How can agents make useful software changes while preserving required behavior?

Reliable agents must manage sequences of actions across repositories, tools, and dependencies. Evidence can become outdated after code changes, and passing available tests does not necessarily establish that a patch addresses the underlying defect.

I would study agents that connect requirements, reasoning decisions, software changes, and supporting evidence. Agents would track established facts, unresolved assumptions, and checks that need repeating. This would guide investigation, tool selection, plan revision, and requests for human review.

Experiments would begin with repository-level repair and maintenance, then extend to changes across interacting components. Agents would combine tests, execution, static analysis, and formal verification where suitable. Evaluation would measure useful completion, functional and selected security regressions, unsupported success claims, recovery cost, and review effort under matched resources.

Together, these directions aim to develop models that learn transferable reasoning and agents that use it to produce software changes supported by clear evidence.