Get Started
Topic · 29 recaps

Code Generation & Program Synthesis

Models that write, edit, and reason about source code — from autocomplete to autonomous coding agents, plus evaluation suites and execution-based training.
PostsQuestions
Home
Topics
Search
Library
Questions researchers are working onFollow a question through Rcap’s explanations and the latest papers addressing it.
How can agent skills support reliable procedural execution while making failures easy to diagnose and repair?When skills are written as free-form prose, agents must repeatedly infer procedural steps, code, commands, and tool calls, which can reduce reliability on implementation-heavy tasks. The same representation makes it difficult to locate failures and safely improve domain-specific procedures.How can AI agents adapt execution routes as runtime evidence invalidates their planned continuation?Agents often commit to a multi-step execution route before intermediate outcomes are known. When those outcomes change what should happen next, stale actions or broad replanning can waste computation and discard useful progress.How can AI agents onboard and control unfamiliar hardware across platforms without bespoke integrations?Integrating each new device commonly requires manual driver selection, dependency setup, interface design, and deployment work. Platform differences make those steps difficult to reproduce and maintain across hosts.How can AI generate attractive graphics with accurate text and editable layers?Bitmap generation often flattens designs, making text unreliable and later edits difficult. Code-based generation preserves structure but can struggle with aesthetic judgment and complex visual assets.How can AI systems build reusable representations for learning novel concepts from sparse data?AI systems often struggle to transfer knowledge from a handful of examples because their learned representations do not capture the structure needed for systematic generalization.How can AI translate executable property-based tests into formal specifications and machine-checked proofs?Property-based tests execute programs, whereas formal verification requires explicit semantics, propositions, and proofs. Bridging the two requires inferring the test's intended property without changing the relevant program behavior.How can autoformalization preserve diverse faithful statements that improve prover search under a fixed budget?A single formal translation can hide other faithful formulations, while syntactic differences among equivalent statements can change how a prover searches. Correctness-only, single-output evaluation therefore misses effects that matter for downstream proving.How can automated Lean 4 proof search reuse promising partial proofs without later revisions degrading them?In real-world Lean projects, proof attempts may contain useful partial progress even when they fail to compile. Continuing the wrong attempt can discard that progress, while exploring too many alternatives wastes inference calls.How can BDD variable ordering minimize quantum circuit cost when BDD size is a poor proxy?Reversible synthesis maps Boolean functions to quantum circuits, but the BDD variable ordering can substantially change the resulting circuit. An ordering that produces a small BDD may still yield an expensive quantum circuit.How can clinical decision systems remain accurate and auditable under scarce, imbalanced data and changing features?Clinical models can become difficult to trust when their predictions are opaque, especially when training data are limited or skewed. Changes in diagnostic criteria and documentation can also make previously learned decision logic unreliable.How can code-generating agents plan programs that satisfy memory and runtime budgets?Without runtime and memory limits, code-generating agents may choose implementations that exhaust resources or miss execution deadlines. These constraints can affect data representation, traversal, and buffering choices before the program runs.How can code-repair models fix bugs without unnecessarily rewriting surrounding code?A repair can pass correctness tests yet alter unrelated code, making review harder and weakening confidence that the original implementation was preserved.How can coding agents maintain accurate repository context as codebases evolve without repeated discovery?Coding agents repeatedly search, navigate, and retain repository information, while code edits can invalidate indexes and prior context. Disconnected tools and task-local histories make it costly to keep retrieved locations and context aligned with the current commit.How can coding agents reliably implement systems-level requirements and detect the defects they introduce?Systems-level tasks combine interacting requirements such as schema design, asynchronous orchestration, configuration, and retrieval behavior. Defects can violate these constraints while remaining undetected, and claimed fixes may go unverified without regression measurement.How can coding agents repair scientific software when domain guidance may mislead them?Scientific software failures can alter both program behavior and the evidence supporting scientific conclusions. Agents may miss domain abstractions, make surface-level repairs, or fail to integrate and generalize changes, while supplied guidance can either constrain repair or cause anchoring.How can coding agents report defective test infrastructure instead of exploiting it to pass?Coding agents may hardcode outputs or modify test files when test infrastructure is defective, allowing them to appear successful while concealing the underlying problem. The challenge is to make reporting the defect a viable response at the point of conflict.How can coding and terminal agents be post-trained without distorting production-faithful token flows and control operations?Simplified training environments and reconstructed logs can change the prompts and token flows encountered in deployment. They can also mix control operations with ordinary model activity, causing training and evaluation to reflect the wrong execution process.How can compiler intermediate representations preserve high-level abstractions in dynamically typed languages while keeping them optimizable?Strongly typed, low-level intermediate representations can be difficult to use for abstractions whose concrete types emerge during specialization. Lowering too early can leave high-level domain libraries outside compiler transformations.How can computational systems discover graph-theoretic conjectures that survive refutation and admit machine-checked proofs?Automated discovery must separate genuinely new conjectures from relations already implied by known results and expose candidates that fail on graphs or targeted searches. Candidates that survive those tests still need precise formal statements and proofs accepted by a trusted kernel.How can continuous diffusion language models reduce denoising steps without sacrificing text-generation quality?Continuous diffusion language models generate text through repeated denoising steps, which can make inference too slow for practical use. Reducing the number of steps may also degrade the quality of generated language.
Previous
1 / 4
Next