betaFeedback

WorksComputer Science

The Vibe Paradox: What EEG Reveals About Your Brain When Vibe Coding

Abstract

Background: Much of the enthusiasm for vibe coding rests on two intuitive beliefs: (1) that developers stay invested even when they no longer write the code, and (2) that delegating more of the work to AI lowers their cognitive load. Objective: Our goal was to investigate whether developers' neurophysiological states and interactions with AI are consistent with these beliefs when they work with agentic vs. non-agentic AI on their own project vs. a legacy codebase. Method: We conducted an exploratory within-subjects crossover study with 11 participants across 22 sessions. Each participant used GitHub Copilot Chat in one session and Cursor Agents in the other, working on their own project and a legacy codebase, with tool-codebase pairings randomly assigned and session order counterbalanced. We recorded participants' EEG, on-screen activity, and prompts, and analyzed 7,924 EEG data points, 984 activities, and 141 prompts. Results: Our findings contradict both beliefs. With the agent, participants remained indifferent to task outcomes, even on their own projects, and cognitive load was higher than with non-agentic AI. Furthermore, their ways of interacting shifted: with non-agentic AI, participants asked how the code worked and read it to verify changes; with the agent, they described desired app behavior and checked results in the running app. Conclusion: Our study reveals a vibe paradox: delegating to an agent left participants motivationally disinterested, even on their own projects, without relieving cognitive load, while coinciding with increased trust in AI. The community should treat this paradox as a first-class concern if developers and their AI agents are to go far together, and not just fast.

Introduction

Consider two development tasks. In the first, you add a feature to a project you built yourself, and a coding agent plans the change, edits the files, and runs the code while you describe what you want. In the second, you fix a bug in a legacy codebase you have never seen, and an AI answers your questions while you make every edit yourself. In which task would you feel more engaged? Which would take more effort?

The first task reflects the promise of vibe coding: developers describe what they want and let AI handle the implementation. Karpathy, who coined the term, described developers reaching a point where they can “forget that the code even exists” [1]. In fact, Pimenova et al. found that developers reported reduced cognitive effort when they vibe coded [2]. Indeed, much of the enthusiasm for vibe coding rests on two intuitive beliefs: (1) that developers stay invested in their own projects even when

they no longer write the code, and (2) that delegating more of the work to AI lowers their cognitive load.

However, neither belief has been tested against what happens with developers as they work; developers’ own reports are often a poor guide. For instance, in one study, experienced developers took 19% longer with AI, while believing it had made them 20% faster [3]. Thus, testing either belief requires objective measures that do not depend on what developers believe about their own work.

Electroencephalography (EEG) offers such measures, continuously and without interrupting work [4]. Kosmyna et al. used EEG to investigate what happens in users’ brains when they write essays with an LLM, and reported weaker brain connectivity than among those writing with a search engine or unaided, along with lower ownership of their essays [5].

Vibe coding makes this inquiry both harder and more pressing [6, 7]. A change to code must cohere with the rest of the codebase, including dependencies the developer may not be familiar with. Moreover, working with an agent is iterative, i.e., developers direct changes, verify them, revert some, and revise their requests over many turns, a different cadence of work from writing an essay. As a result, their effort and their investment in the outcome may fluctuate as the work unfolds. This inquiry is especially important now, because vibe coding has lowered the barrier to producing software [6], so that end-user developers, who write software for their own purposes [8], can now produce it as well. While EEG has been used to study programming tasks such as code comprehension [9], to the best of our knowledge, no work has studied people’s neurophysiological states while they vibe code and what producing software this way costs to them.

In this paper, we thus ask:

RQ1: How do participants’ neurophysiological states differ when they work with agentic versus non-agentic AI, on their personal project versus a legacy codebase?

RQ2: How do participants’ interactions differ across these conditions?

To investigate these questions, we conducted an exploratory within-subjects crossover study in which 11 participants vibe coded with non-agentic AI (GitHub Copilot Chat [10]) and an agent (Cursor Agent [11]). Each participant used one AI type on their own project and the other on a legacy codebase, with the pairing randomized and session order counterbalanced. We recorded 7,924 EEG instances, 984 on-screen activity transitions, and 141 prompts across 22 sessions.

Our findings suggested that with the agent, participants’ approach–withdrawal motivation (AW), an EEG measure of a person’s tendency to be motivationally invested in the current activity [12, 13], stayed near neutral, even on their own projects, and that the agent brought no relief in cognitive load [14], which was, if anything, higher than with non-agentic AI (RQ1). Furthermore, participants’ ways of interacting changed with the AI type. With non-agentic AI, they worked at the level of the code, asking how it worked and reading it to check changes. With the agent, they moved up a level of abstraction, where their interactions centered on the app’s behavior and outcomes (RQ2). Interestingly, participants who used the agent on the legacy codebase (and non-agentic AI on their own projects) also reported higher trust in AI than those with the reverse pairing.

Most critically, these effects together surface what we call the vibe paradox: delegating to an agent (1) caused participants to be indifferent to outcomes, even on their own projects, (2) brought no relief in cognitive load, and (3) coincided with higher trust in AI. We frame this motivational indifference as interest atrophy, a weakening of investment in outcomes that participants no longer produced themselves. We argue that what agents save developers in keystrokes, they may charge to developers’ motivational investment and cognitive load.

Our work makes three contributions: (1) evidence of developers’ neurophysiological states when they vibe code with agentic and non-agentic AI on different projects; (2) an account of how participants’ interactions and ways of working changed with the agent, surfacing signs of material disengagement [6] in software development; and (3) the vibe paradox, interpreted through supervisory control [15], reward from one’s own choices [16, 17], motivational intensity [18], and automation complacency [19].

Studies of how developers work with AI have mostly examined code completion and chat. Barke et al. found that developers used Copilot in an acceleration mode, to reach a solution they already had in mind faster, and in an exploration mode, to explore options when they were unsure how to proceed [20]. Mozannar et al. found that thinking about and verifying Copilot’s suggestions took the largest share of developers’ time [21]. Agents shift this work. Developers needed less effort to finish tasks with an agent than with a copilot, but did not always understand what the agent had done [22], and in real-world chat sessions they delegated diagnosis, comprehension, and validation to the AI [23]. Sarkar and Drosos describe vibe coding as material disengagement, in which the developer stops working the code and instead orchestrates its production through the AI [6]. Vibe coders who relied more on AI re-prompted with the same intent until something worked [24], whereas experienced developers kept control of design and implementation [25]. Like these studies, we code developers’ activities and prompts, but we compare where the same developers check the AI’s work, in the code or in the running app, with each AI type and on code that is and is not their own, and we relate these interactions to EEG.

The enthusiasm for vibe coding rests largely on what developers say about it. Karpathy, who coined the term, described accepting the AI’s changes without reading the diffs [1], and developers report that vibe coding brings flow and joy and reduces cognitive effort [2]. Such reports can diverge from measurement. In a randomized trial, experienced open-source developers believed AI had made them 20% faster when it had made them 19% slower [3]. We examine whether the two beliefs behind vibe coding, that developers stay invested and that delegating lowers their load, hold when developers’ states are measured during the work.

Other studies have measured what delegating to AI costs. Projects that adopted Cursor gained development velocity briefly but accumulated lasting static-analysis warnings and code complexity [26]. Students who built a website with an agent understood their code less and were less able to extend it than students who used a chatbot, and low-effort interactions, such as auto-accepting edits, were linked to lower comprehension [27]. Developers with an AI assistant wrote less secure code while believing it to be more secure [28]. Because these studies rely on post-task code metrics, comprehension tests, and self-reports, they show that delegation has costs but not how invested developers were, how much load they carried, or how they checked the AI’s changes while they worked, which our EEG and interaction coding capture.

Physiological measures can capture developers’ states as they work. In software engineering, they have been used to assess task difficulty [4], emotions and progress [29], flow experience [30], and cognitive load during code comprehension [9], all without AI, and eye tracking has shown how developers validate and repair Copilot-generated code [31]. Outside programming, people who wrote essays with an LLM showed weaker brain connectivity on EEG than those who used a search engine or no tool, and they reported less ownership of their essays [5]. We follow this work in measuring developers’ states during the task, using EEG measures of approach–withdrawal and cognitive load [12, 14]. To our knowledge, no study has measured developers’ neurophysiological states while they vibe code with an agent, or compared these states on their own code and on code new to them.

Method

Our goal was to describe how participants’ neurophysiological states (RQ1) and their interactions with AI (RQ2) differ when they work with agentic versus non-agentic AI, on their personal project versus a legacy codebase. To do so, we conducted an exploratory within-subjects crossover study in which n=11n = 11 participants completed 22 sessions (see Figure 1). To answer RQ1, we recorded and analyzed participants’ neurophysiological states with EEG; to answer RQ2, we analyzed their interactions with the AI through screen recordings and prompts (Sections III-F and III-G). Our institution’s IRB approved the study.

Study workflow showing counterbalanced sessions, EEG, screen recordings, prompts, and measures for RQ1 and RQ2

Figure 1. Study workflow. Each participant completed two counterbalanced sessions, differing in AI type and project, each after a resting baseline. EEG, screen recordings, and prompts, aligned in time, yield the measures for RQ1 and RQ2.

Study Design

Because we studied vibe coding [1, 6], participants worked with AI in every session. To examine the two beliefs in § 1, we varied who made the changes to the code, the participant or the AI (AI type), and whether participants worked on their own project (project type).

With non-agentic AI, participants used GitHub Copilot Chat [10], which answered questions and proposed changes that participants could apply themselves. Inline code completion was also enabled. With agentic AI, participants used the Cursor agent [11], which inspected the project and edited files directly. Both tools were model-agnostic interfaces, in which the user could select the language model behind the tool, and participants could choose any model that each tool offered. AI type therefore varied how much autonomy the AI had in making changes to the code, independently of any particular model. Each session started from a fresh instance of the tool with its memory of earlier sessions cleared, so every participant began from the same state. For project type, each participant worked once on their own project and once on a legacy codebase (Section III-C).

Each participant completed two 20-minute sessions, a length recommended by OpenBCI for the headset, in a crossover design in which each participant used both AI types and worked on both project types (Figure 1). Participants were randomly assigned to one of two groups: Group A (n=5n = 5) used non-agentic AI on the legacy codebase and agentic AI on their own project; Group B (n=6n = 6) used the reverse pairing. We counterbalanced session order within each group.

Participants

We recruited participants between May and August 2026 by inviting 1,260 students through an undergraduate software engineering course, the university’s recruitment list for online-program students, and snowball sampling. Participants were required to be at least 18 years old, to have programming and SE experience alongside experience with AI tools, and to provide a personal software project, in any programming language, that could be built and executed, with one or more planned changes they could attempt within 20 minutes. Because the headset’s dry electrodes required direct scalp contact, participants also had to be able to wear the headset with an appropriate fit, work without glasses, and remove earrings or head coverings. Twenty-two of those invited completed the screening survey. We reviewed each respondent’s project and planned changes against these criteria before inviting them to the study, and 16 enrolled and attended a session. Four could not complete the study: three could not achieve a stable headset fit (hair texture for two, eyewear for one), and a lab computer failure ended one session. Twelve participants completed both sessions (see participant demographics in the supplemental material [32]). We excluded one of them because of a substantial time gap in their EEG data. Participants who completed the study received a $60 Amazon gift card.

Tasks

Personal project. Each participant provided a software project they had developed themselves. Before the session, they listed features they wanted to implement with observable completion criteria. We set up each project to build and execute on the laboratory computer before the session. To measure task performance, we checked each listed feature against its observable completion criteria and computed the proportion of listed features the participant completed.

Legacy codebase. The legacy codebase had to be new to the participants and the models, so we used a non-public web application for speedgolf (name withheld for review). Because its source is not public, it is unlikely to have appeared in the models’ training data. Participants completed one feature in it: a form for entering a new tournament’s details, such as its name, host, and dates, and a button that saves the tournament and exits the form. Instead of written requirements, participants received screenshots of how the application should look once the feature worked. To measure task performance, we checked each participant’s work against a set of 22 automated test cases and counted the test cases it passed; a test case with two parts received half credit when one part passed.

Apparatus

Computer and software. Participants worked on a Windows 11 laboratory computer. For non-agentic AI, Copilot Chat ran inside Visual Studio Code; for agentic AI, participants used the Cursor agent on the Pro plan. By default, Copilot Chat selected its model automatically and Cursor used Claude Opus 4.6, unless participants chose another model. Participants were not allowed to use any generative AI other than the tools provided.

EEG headset. We recorded EEG with the OpenBCI Galea Beta [33], a head-mounted device that combines EEG with electrooculography (EOG) and motion sensing by an inertial measurement unit (IMU) (see Figure 2). Its 10 active dry electrodes need no conductive gel, keeping setup short, and sit at positions of the international 10–20 system: a frontal pair (F1, F2), three central sites (C3, Cz, C4), three parietal sites (P3, Pz, P4), and two occipital sites (O1, O2). It samples EEG and EOG at 250 Hz and motion at 50 Hz. We used the EOG channels to remove eye-movement artifacts and the motion sensors to reject windows with head movement. We synchronized the EEG and screen recordings by aligning the task-start timestamps.

The 10–20 system, the OpenBCI Galea Beta headset, and the headset worn at a computer

Figure 2. (a) The 10–20 system, with the ten sites present in the Galea system highlighted. (b) The OpenBCI Galea Beta [33], worn without its VR display, with the electrodes numbered. (c) The headset as worn at a computer.

Procedure

We collected data between May 22 and September 2, 2026. Before data collection, we conducted five sandbox sessions to test the equipment and procedure, and we began data collection once a sandbox session required no further changes. We excluded the sandbox data from all analyses. After providing informed consent, participants followed the same procedure for each task (Figure 1). Before any tasks, participants reported their background and experience with AI. Before each task, a researcher reviewed the requirements with the participant and asked them to restate the requirements in their own words to confirm their understanding. We fitted the EEG headset and checked each electrode’s signal quality, which took around 5–8 minutes depending on the participant. Participants then completed a six-minute baseline of three two-minute tasks: mental arithmetic, eye movements, and eyes-open rest. Mental arithmetic raises cognitive load [34], eye movements elicit the ocular artifacts that EOG-based correction removes [35], and eyes-open rest provides a resting reference [36]. We used the eyes-open rest as the reference for cognitive load (Section III-F). The participant then worked on the task for 20 minutes while a researcher monitored the EEG recordings. Participants were not asked to think aloud, as verbalizing their thoughts would have imposed additional cognitive load. The two tasks were separated by a 10-minute break. After both tasks, participants were asked to rate their trust in AI using the 5-point Likert TXAI scale [37, 38].

Data

We captured neurophysiological states (RQ1) in 2-second EEG windows, a common approach for spectral EEG measures [39]. A 2-second window is short enough to fall within a single activity and long enough to estimate theta and alpha power at 1-Hz resolution. For interactions (RQ2), the units of analysis were transitions between activities, interaction cycles, and prompts (Section III-G).

Activity coding. To link each EEG window to what participants were doing, two researchers coded the screen recordings continuously with 12 codes (supplemental material [32]), which make up the four activities we analyzed. They first coded 20% of two participants’ recordings independently to develop the scheme, and then 20% of every participant’s recordings. After reaching more than 80% agreement, they divided the remaining recordings between them. Each change from one coded segment to the next is a transition (Figure 1). We grouped the codes into four activities in two categories: articulation (writing prompts: composing or revising a prompt) and verification (reading AI output: reading the AI’s response or diffs; reading code: reading code or navigating files; viewing the app: viewing or interacting with the running application). We excluded actions related to workflow configuration and idle time.

Prompt coding. We transcribed the 141 prompts from the recordings and coded each for its intent type and articulation effort (Table I); a prompt could receive more than one code. From each prompt’s intent type, we derived whether it pointed at the code or at the app. Following Choudhuri et al. [40], the codebook includes the code, its definition, and examples, and retains only codes found in prompts from distinct participants. We coded the prompts with two AI models. Claude Opus 5.5 derived the codebook and applied it, and GPT-6 independently critiqued and coded all prompts as a second coder alongside Claude. Two authors then manually reviewed the codebook and spot-checked the coding. Overall agreement between the two models (Cohen’s κ\kappa) was 0.83.

A Intent type: what the prompt asks forExampleNon-agentic AI Legacy (43)Non-agentic AI Own (33)Agentic AI Legacy (36)Agentic AI Own (29)
Working in the code46%45%12%0%
learning how the code works“what are the paths to these files?”23%24%6%0%
asking for code and where it goes“help me write route for cart”23%21%6%0%
Directing changes to the app“Make the shadow a little bigger . . . ”23%30%56%86%
Reporting what is broken16%30%42%20%
in the app’s behavior“the save & exit button is not working”9%3%39%10%
in errors and test output“fmod is not declared”2%24%0%7%
in the AI’s own work“None of those worked, try reading . . . ”5%3%3%3%
Intervening in the workflow35%15%12%13%
approving, advancing, or retrying“yes”; “Next element”16%0%3%0%
handing over changes to implement“Go ahead and implement”5%6%6%3%
asking for a plan first“. . . can we create a plan to do so”7%3%0%3%
setting the pace and form of the AI’s answers“One element at a time. Let’s start slow.”7%6%3%7%
B Where the prompt points
Directed at the code49%64%11%7%
Directed at the app28%33%72%90%
C Articulation effort: what the participant put into the prompt
Direct request: states only what is wanted“help me find new tournament page”60%39%25%10%
Adds context: what happens now, what was tried, or why“. . . it didn’t receive and update the value on the screen that I gave”21%33%50%45%
Adds specification: constraints, criteria, approach, scope, or contingencies“. . . text should also be larger, aim for accessibility heuristics to be followed”26%39%36%79%

Table I. TABLE I. WITH THE AGENT, PROMPTS WERE DIRECTED AT THE APP MORE OFTEN THAN WITH NON-AGENTIC AI. CELLS GIVE THE SHARE OF EACH CONDITION’S PROMPTS (nn) WITH THE CODE; EACH INTENT SUMS ITS SUB-INTENTS. SHADING MARKS THE HIGHER AI TYPE, NON-AGENTIC / AGENTIC.

EEG processing. For each EEG recording, we applied a bandpass filter from 0.5–100 Hz and a notch filter at 60 Hz for mains noise. We screened each recording’s power spectrum for flat channels and channels with abnormally high power, and we interpolated the channels we judged unusable on inspection by spherical spline from neighboring sites. We then removed ocular artifacts using EOG regression and re-referenced the signal to the common average of all channels. We split each recording into non-overlapping 2-second windows. Within each window, we estimated each channel’s power spectrum with Welch’s method (1-second Hann-tapered segments with 50% overlap, giving 1-Hz resolution) and averaged power over the bins in the theta (4–8 Hz) and alpha (8–13 Hz) bands, with 8 Hz included in both bands. We rejected windows in which head motion exceeded three standard deviations of the recording’s motion signal and windows whose samples were not contiguous in time. We assigned each window that passed rejection to the coded activity that spanned its full duration, which yielded 7,924 windows from 20 sessions. We excluded the EEG from two agentic AI sessions on personal projects because the headset’s electrodes did not record a usable signal in those sessions. Their interaction data could still be recovered from the screen recordings and prompts.

EEG measures. To capture whether participants tended to approach or withdraw from an ongoing activity, which we call approach–withdrawal (AW), we used frontal alpha asymmetry (FAA) [12], [13] (Figure 1). Following the right-minus-left convention [12], we computed FAA in each window as ln⁡αF2−ln⁡αF1\ln\alpha_{F2} - \ln\alpha_{F1}, where αc\alpha_c is alpha power at channel cc. Because alpha power varies inversely with cortical activity, positive values indicate relatively greater left frontal activity (approach), and negative values indicate withdrawal. Approach motivation is the impetus to move toward a goal or activity, and withdrawal motivation the impetus to move away from it [13]. A participant invested in their work would therefore show AW that leans toward approach. Because FAA compares simultaneous recordings from two sites, it does not require a baseline. To capture cognitive load, we used the ratio of frontal theta power to parietal alpha power, which rises with working-memory demand [14], [41] (Figure 1). In each window ww, we computed the index Iw=θˉF/αPzI_w = \bar{\theta}_F / \alpha_{Pz}, where θˉF\bar{\theta}_F is theta power averaged over F1 and F2, and expressed load relative to eyes-open rest as ln⁡(Iw/I~rest)\ln(I_w/\tilde{I}_{\mathrm{rest}}), where I~rest\tilde{I}_{\mathrm{rest}} is the median index over the rest windows of the same recording. Load is therefore 0 at the resting level and positive above it.

G. Analysis

RQ1: Neurophysiological states. To describe participants’ neurophysiological states, we report each EEG measure’s distribution across windows by AI type, project type, and activity: its median (MM), its 5th and 95th percentiles (P5P_5 and P95P_{95}), which bound the central 90% of windows, and for AW, the share of windows with a strong asymmetry. We call an AW value strong when it falls outside Tukey’s fences [42], 1.5 interquartile ranges beyond the quartiles. We computed the fences from all windows pooled across conditions so that they do not depend on AI type.

RQ2: Interactions. To describe how participants moved between articulating their intent and verifying the AI’s work, we computed the transitions between the four analyzed activities, treating consecutive instances of one code as a single visit. We also divided each session into interaction cycles. We write PP for writing prompts 💬 and V={O,C,A}V = \{O,C,A\} for the verification activities reading AI output ✨ (OO), reading code 🧑‍💻 (CC), and viewing the app 🖥️ (AA). A session is a sequence of visits v1,…,vnv_1,\ldots,v_n, each to one activity a(vi)∈{P}∪Va(v_i) \in\{P\} \cup V, with t1<⋯<tnt_1 < \cdots< t_n be the positions of the visits to PP, with tm+1=n+1t_{m+1} = n + 1. Interaction cycle kk is the set of verification activities visited between two visits to PP, Ck={a(vi):tk<i<tk+1}⊆VC_k = \{a(v_i): t_k < i < t_{k+1}\} \subseteq V. We kept the 187 cycles that included at least one verification activity (Ck≠∅C_k \ne\varnothing). Cycles outnumber the 141 prompts because some visits to writing prompts 💬 ended without a prompt being sent.

To show how close participants came to the implementation when they verified, we ordered the verification activities from the outside in: the running app (behavior), the AI’s output (its account of what it changed), and the code (the implementation). For each activity x∈Vx \in V, we computed the share of cycles that included it, ∣{k:x∈Ck}∣|\{k: x \in C_k\}| divided by the number of cycles. For each cycle, we also recorded the sequence of verification activities in the order participants first reached them after the prompt. For example, the chain prompt → AI output → code describes a cycle in which the participant read the AI’s output and then the code, without viewing the app (see Figure 4).

Figure 4. With the agent, participants verified the AI’s work in the app more often than with non-agentic AI, and in the code less often. Left: non-agentic AI; right: agentic AI; both project types pooled. Layers run from the app (outside) through the AI’s output to the code (center); writing prompts opens each cycle. Circle number = % of interaction cycles that included the activity (area proportional); solid, numbered arrows = ≥25% of the transitions out of an activity; faint arrows = 10–25%; inward transitions above the axis, outward below; dotted outline = the most frequent loop.

Statistical tests. For the interaction measures and the prompt codes, we compared each participant’s two sessions by AI type with exact Wilcoxon signed-rank tests [43], reporting the magnitude of the matched-pairs rank-biserial correlation (rr) [44] as the effect size and reading 0.5 or more as large [45]. Because project type also differed between each participant’s two sessions, we assessed its effect by comparing agentic-minus-non-agentic differences across the two groups using exact Wilcoxon rank-sum tests [46], following the analysis of two-period crossover designs [47]. To check whether AI type affected the quality of participants’ work, we also compared task performance by AI type within each project type, between the two groups, with the same rank-sum test. Task performance was the proportion of listed features completed on personal projects and the number of automated test cases passed on the legacy codebase (Section III-C). The tests treat participants as the independent units, so each participant contributed one share per AI type, computed over that session’s interaction cycles, transitions, or prompts. The percentages in Results pool these cycles, transitions, and prompts across participants. We applied the Benjamini–Hochberg correction [48] within each set of related measures (transitions, the share of interaction cycles that included each activity, and the prompt codes we compared in Table I). Following the American Statistical Association’s statement on pp-values [49], we treat differences that did not survive correction, and comparisons of the four combinations of AI type and project type, as descriptive.

AI usage

We used Claude Opus 5.5 and GPT-6 to (1) create an initial EEG analysis pipeline, whose code the authors reviewed for correctness; (2) derive and apply the prompt codes (Table I) and second-code them for reliability, with the authors reviewing the codebook and spot-checking the coding; and (3) design figures and copyedit.

Threats to Validity

Construct validity. We recorded EEG with a wearable dry-electrode headset so that participants could program without gel or lengthy preparation. As Knierim et al. note for wearable EEG, such signals are noisier than those from laboratory gel-based systems, and findings from one sensor setup may not transfer to another [30]. The headset’s frontal pair, F1 and F2, lies next to the F3 and F4 sites that asymmetry studies conventionally use [12]. We therefore report AW and cognitive load descriptively, over 2-second windows that passed ocular and motion artifact rejection, and interpret distributions across windows. Finally, reading code does not separate code that participants wrote from code the AI changed, and we did not measure comprehension, so our discussion of program understanding draws on prior work (§ 6).

Internal validity. Our study had no condition without AI, so we cannot compare participants’ states or interactions with programming unaided. We left out such a condition by design: our questions concern vibe coding, in which developers work with AI throughout [1], [6], so the comparison of interest is between two ways of working with AI. Each participant’s two sessions differed in both AI type and project type, and we separated the two factors in the interaction measures with the standard analysis for crossover designs (Section III-G); because one combination has EEG from only three participants, we describe the EEG measures rather than test them. The two AI types also differed in IDE and default model. Both tools let participants choose any model they offered, as developers can in practice, and participants were asked to let the agent make the changes, as agentic tools are designed to be used.

External validity. Our n=11n = 11 participants were students with development experience at one university. A sample skewed toward academia limits generalization to professional developers [50]. 20-minute laboratory sessions may not capture how developers work with AI over days [50], brain data vary from day to day [30], and newer agents may change the patterns we observed. We offer these patterns as exploratory evidence of where studies with professional developers, longer periods of use, and newer agents should look.

Results

We investigated two beliefs about vibe coding: (1) that developers stay invested when an AI makes the changes, and (2) that delegating to an AI agent lowers their cognitive load. Our study found that with the agent, participants’ AW stayed near neutral and their cognitive load was in fact higher than with non-agentic AI, contradicting both beliefs (Sec. V-A). To understand these patterns, we then examined how participants interacted with each AI type across the two project types (Sec. V-B).

Neurophysiological States Across Treatments (RQ1)

Figure 3 shows participants’ AW and cognitive load for each activity (columns i–iv) and each combination of AI type and project type. If owning the code had kept participants invested, their AW would naturally have leaned toward approach on their own projects regardless of who made the changes. If delegating had lightened the work, their cognitive load would have been lower with the agent than with non-agentic AI. However, the data showed otherwise on both counts.

Figure 3. With the agent, AW stayed near neutral and cognitive load was higher than with non-agentic AI. Rows: AW (a) and load (b); columns: activities (i–iv). Each violin shows 2-second EEG windows (counts above row a); white dots mark medians, black bars the interquartile range. Arrows in row a span each AI type’s 5th to 95th percentile; dashed lines in row b mark each AI type’s median load, and small arrows the step between them. Zero marks symmetry for AW and the resting baseline for load.

  1. Approach–withdrawal: With the agent, participants’ AW stayed near neutral on both project types (own projects: M=−0.04M = -0.04; legacy codebase: M=0.17M = 0.17) and across every activity (see Figure 3a). Strong asymmetries in either direction were rare with the agent (5% of windows, compared with 21% with non-agentic AI), which indicates that participants were largely motivationally indifferent to the outcomes when working with the agent, regardless of project type. In contrast, with non-agentic AI on their own projects, participants’ AW leaned toward approach (M=0.38M = 0.38), most of all while they interacted with the AI’s output (M=0.67M = 0.67; Figure 3a(ii)). Furthermore, with non-agentic AI on the legacy codebase, AW departed strongly toward both approach and withdrawal (35% of windows showed a strong asymmetry, compared with 7% on participants’ own projects), most of all while participants wrote prompts (M=−0.34M = -0.34; Figure 3a(Figure 3i)), suggesting that participants at times leaned toward the work in the legacy codebase and at times withdrew from it.

Understood through the lens of material disengagement [6], AW departed from neutral when participants worked with the AI in a non-agentic mode and stayed near neutral when the AI instead worked for them. In fact, a pharmacological EEG study showed that approach-related frontal asymmetry depends in part on dopamine [51], and recordings from dopamine neurons in primates showed that these neurons respond to outcomes that are better or worse than expected [52], with activity that rises when the outcome is worse than expected [53]. With non-agentic AI, each change that participants chose and applied had an outcome they waited on, i.e., a step toward their own goal on their own projects, consistent with AW leaning toward approach, and a less predictable step in the legacy codebase, consistent with AW departing toward both approach and withdrawal. We describe where participants’ work and attention went instead in § 5-B, and discuss what the agent’s changes did to this reward in § 6.

  1. Cognitive load: With the agent, participants’ cognitive load was higher than with non-agentic AI on both project types (own projects: M=0.94M = 0.94 vs. 0.67; legacy codebase: M=0.49M = 0.49 vs. 0.25; see Figure 3b). Of the four combinations of AI type and project type, load was highest with the agent on participants’ own projects. The difference between the AI types was largest while participants wrote prompts (M=0.81M = 0.81 vs. 0.39) and viewed the app (M=0.74M = 0.74 vs. 0.45; Figure 3b(Figure 3i) and b(iv)), i.e., while they stated what they wanted and then checked what the app did. In contrast, while participants read the AI’s output and the code, load differed less between the AI types ($M = 0.56

vs. 0.49 and 0.53 vs. 0.40). This pattern indicates that with the agent, participants’ load was mostly concentrated in stating their intent and checking the app’s behavior, which we describe in § 5-B.

Furthermore, load was also higher on participants’ own projects than on the legacy codebase with both AI types (non-agentic AI: M=0.67M = 0.67 vs. 0.25; agent: M=0.94M = 0.94 vs. 0.49), even though participants knew their own code better. The difference appeared mainly while participants read the AI’s output (non-agentic AI: M=1.00M = 1.00 vs. 0.18; agent: M=1.04M = 1.04 vs. 0.10) and the code (non-agentic AI: M=0.63M = 0.63 vs. 0.11; agent: M=0.93M = 0.93 vs. 0.28; Figure 3b(ii) and b(iii)). One explanation comes from motivational intensity theory, which holds that involvement of the self makes success important and so justifies mobilizing more effort [18]. By this account, participants may have invested more effort in understanding changes to software that was their own, which would explain this difference.

With the agent on their own projects, participants also faced demands around verifying the agent’s changes from the outside in, i.e., running the app and checking its behavior. In this condition, 86% of prompts directed changes to the app, compared with 30% with non-agentic AI on the same project type, whose prompts more often pointed at the code (64%), and 79% added a specification, compared with 39% (see Table I). Such prompts asked the agent for larger changes, and subsequently verifying them in the app came with higher load than with non-agentic AI on the same project type (M=0.80M = 0.80 vs. 0.47). § 5-B1 examines these prompts, and § 5-B2 how participants verified the agent’s changes.

RQ2: Interactions Across AI and Project Types

In RQ2, we investigated how participants’ interactions with each AI type differed across the two project types. Specifically, we report how participants’ intent articulation (§ 5-B1, Table I) and their verification of the AI’s work (§ 5-B2, Figure 4) differed across these conditions. Pennington distinguishes two levels of abstraction at which programmers represent a program: the program model, which concerns the code’s text and its control flow, and the domain model, which concerns what the program does [54]. Our data showed a similar distinction. With non-agentic AI, participants’ prompts and verification more often concerned the program model, whereas with the agent, they more often concerned the domain model, centering on the app’s behavior and outcomes.

1) Intent articulation moved from the code to the app: Table I lists participants’ prompts by what participants asked the AI to do (part A), where their prompts were directed (part B), and what they added alongside the request (part C).

Overall, with the agent, participants’ prompts were directed less toward the code and more toward the app: 72% of prompts on the legacy codebase and 90% on participants’ own projects were directed at the app, compared with 28% and 33% with non-agentic AI, differing significantly with a large effect (p=0.010p = 0.010, r=0.89r = 0.89; see Table IB).

Participants also differed in what they asked the AI to do with these prompts. With the agent, they mostly directed changes to the app’s behavior, e.g., “Make the shadow a little bigger extending to the right more . . . ” (56% of prompts on the legacy codebase and 86% on their own projects, compared with 23% and 30% with non-agentic AI). In contrast, with non-agentic AI, participants more often worked in the code, asking how it worked, e.g., “what are the paths to these files?”, or asking for code and where to put it, e.g., “help me write route for cart” (46% of prompts across both project types, compared with 6% with the agent; see Table IA). They also more often intervened in the workflow, approving, advancing, or retrying the AI’s work (e.g., “yes”; “Next element”), handing over changes to implement, asking for a plan first, and setting the pace and form of its answers (26%, compared with 12%). Because non-agentic AI proposed one change at a time, participants had to tell it when to proceed, whereas the agent carried out multi-step changes on its own.

Finally, participants differed in what they provided alongside their requests. With non-agentic AI, many prompts were direct requests that stated only what was wanted, e.g., “help me find new tournament page” (60% and 39%, compared with 25% and 10% with the agent; see Table IC). On the other hand, since participants handed the agent whole changes, they added more context to their prompts to the agent, such as what the app was doing then, e.g., “. . . it didn’t receive and update the value on the screen that I gave” (48% of prompts, compared with 26% with non-agentic AI), alongside more specification, such as constraints on the result, e.g., “. . . text should also be larger” (55%, compared with 32%). Recall from Figure 3b(Figure 3i) that writing prompts was the activity in which load differed most between the AI types (M=0.81M = 0.81 vs. 0.39), and this added context and specification coincided with that higher load.

2) Verification moved from the code to the app: Figure 4 shows how participants verified the AI’s work with each AI type. The three verification activities form layers, from the running app on the outside, through the AI’s output, to the code at the center. Each circle gives the share of interaction cycles that included that activity, each arrow shows how often participants transitioned from one activity to another, and the dotted outline marks the most frequent loop.

Overall, with the agent, participants’ verification moved outward, from the code to the app: they read the code in 34% of interaction cycles on the legacy codebase and 29% on their own projects, compared with 62% and 73% with non-agentic AI, with a statistical significant difference and a large effect (p=0.006p = 0.006, r=0.93r = 0.93).

Participants also differed in where they went after interacting with the AI’s output. With non-agentic AI, 76% of these transitions went to the code and 8% to the app; in contrast, with the agent, 32% went to the code and 50% to the app, with the transitions to the code differing significantly with a large effect (p=0.001p = 0.001, r=0.99r = 0.99). As a result, the most frequent loop with non-agentic AI ran between the AI’s output and the code, whereas with the agent it ran between the AI’s output and the app (see the dotted outlines in Figure 4).

Furthermore, participants checked the running app more often with the agent, viewing it in 83% of interaction cycles, compared with 47% with non-agentic AI. The most common cycle differed accordingly: with non-agentic AI, participants moved from the prompt to the AI’s output and then to the code (26% of cycles); with the agent, they moved straight from the prompt to the app, bypassing both the AI’s output and the code (28%). This shift aligned with where participants directed their prompts (recall § 5-B1).

Situation awareness research suggests that people supervising automation must first reconstruct their understanding of the system’s state before judging it [55]. Supervising the agent through the app, a level of abstraction above the code, may have required this reconstruction, contributing to the higher load during app viewing across project types (recall M=0.74M = 0.74 vs. 0.450.45; Figure 3b(iv)). This supervisory role also aligns with participants’ motivational indifference: their AW remained near neutral with the agent across project types (Figure 3a).

Situation awareness may also help explain the difference in

trust between the two groups. Group A (recall Figure 1) used the agent on their own projects, where they were more familiar with the agent’s working context, and non-agentic AI on the legacy codebase, where they made atomic changes when working with AI. Group B had the reverse pairing, coinciding with lower situation awareness. Consequently, Group B reported higher trust in AI than Group A, although this greater trust was not warranted by task performance, which did not differ significantly between the groups on either project type (see the supplemental material [32]). We return to this pattern in Section VI when discussing over-reliance on AI.

Discussion and Concluding Remarks

Two Myths of Vibe Coding, Busted! Much of the case for vibe coding rests on two beliefs: that developers stay invested in their own projects even when they no longer write the code, and that delegating to an agent lowers their load [1, 7, 56]. Our findings contradicted both.

The Vibe Paradox

Vibe coding promises that developers can “forget that the code even exists” [1]. With the agent, our participants got no relief in cognitive load and showed interest atrophy, and those who used it on the code they knew least reported higher trust in AI. Together, these three effects are what we term the vibe paradox. To explain the paradox, we consider four theories in concert: supervisory control [15], reward from one’s own choices [16], motivational intensity [18], and automation complacency [19]. Figure 5 shows the paradox as the meeting of these four theories.

Figure 5. The vibe paradox. Four theories on the rim shape the two effects at the hub that participants showed with the agent: interest atrophy (AW near neutral) and cognitive burden (no relief in cognitive load). Reward from one’s own choices feeds interest atrophy, and motivational intensity, supervisory control, and automation complacency shape cognitive burden.

From working the code to supervising it. When participants worked with the agent, they no longer made the changes themselves. They told the agent what they wanted the app to do and then checked the result in the running app (§ 5-B). Human factors research calls the role this leaves a person in supervisory control, instructing an automated system and monitoring it while it carries out the task [15], and Vella argues that coding agents have put software engineers in this role without appropriate work redesign [57].

No relief in cognitive load. Supervisory control explains why participants got no cognitive load relief. Recall that cognitive load was higher with the agent than with non-agentic AI on both project types. Automating a task leaves the human with the harder job of monitoring it and taking over when it fails [58], a pattern also found in generative AI [59]. With a coding agent, this burden reaches past monitoring the app to stating intent. Indeed, load with the agent exceeded load with non-agentic AI most at exactly these two points (§ 5-A).

Interest atrophy. Supervisory control does not explain why participants’ AW stayed near neutral with the agent, even in their own code. Approach motivation is tied to reward from one’s own choices (§ 5-A), and research on reward from one’s own choices shows that reward-related brain responses are weaker when outcomes do not depend on those choices [16], and that the sense of agency fades when actions are not one’s own [17]. With the agent, the choices behind each change were the agent’s. We coin interest atrophy for this weakening of developers’ investment in an outcome when they no longer make the changes themselves. That is, individuals’ interest may depend on making the changes as much as on owning the code.

Effort without interest. If reward were the whole story, weaker interest would have meant less effort. Instead, load was highest with the agent on participants’ own projects. Motivational intensity theory explains this, because involvement of the self makes success important and so justifies effort (§ 5-A). Participants still needed the work to succeed, so they paid in effort, though it no longer drew them in.

Over-reliance on AI. In contrast, participants had no such stake in the legacy codebase. Recall that their load there was lower than on their own projects (§ 5-A), even though they knew that code least and it may have been the hardest to verify. That is, checking may have cost the most effort where they had the least reason to spend it. Operators who supervise automation come to rely on it without checking its output, a pattern known as automation complacency [19], and users of AI over-rely on output they cannot verify [60]. Consistent with this, participants who used the agent on the legacy codebase reported higher trust in AI than the other participants.

Both beliefs picture an agent that takes the effort off developers’ hands and leaves their interest in place. Our participants got the reverse. Delegating took away the part of the work that rewarded them and left them the part that cost them, and where they knew the code least, they reported trusting the AI more.

The Vibe Paradox and Solo Software Development

Multi-agent frameworks such as ChatDev and MetaGPT assign the roles of a software team to separate agents [61], [62], making possible what we call solo software development (SSD), in which one developer directs an agent or a team of agents. Ashby’s Law of Requisite Variety holds that only variety, the number of different things a system can do, can absorb variety [63]. A team of agents can change the process, the product, and what people understand of both in far more ways than one developer can follow, and coordination costs grow faster than the team [64]. So a developer stays in control only if they and their tools can absorb the variety the agents produce. Our participants’ higher load, and their reading of the code in only a third of cycles, suggest that a prompt and a running app already fall short with one agent. The law gives us three knobs: amplify, attenuate, and maintain.

Amplify what the individual can absorb. Load was higher when participants checked changes in the app, which shows what the program does but not how its parts relate. Tools can show an agent’s changes in the structure of the system; for example, Vibe-GUIDE’s live graph of a project supported developers’ project comprehension relative to a chat-only interface [65]. Tools can also absorb variety themselves by running tests and checks with each change [57], so that only what they cannot settle reaches the developer.

Attenuate what the agents produce. Our two AI types sat at fixed points on the automation dial for a whole session [66]. Setting this dial per change lets agents act alone on routine edits but wait on changes that touch a concept central to the system, asking the developer to predict or make them first. Smaller steps leave less to absorb and keep with developers the choices that make an outcome theirs, which developers protect by delegating less of the work tied to their identity [67].

Maintain the match as the work goes on. Each accepted change moves the system away from what the developer last understood, and a good regulator of a system must be a model of that system [68], so the developer’s model has to keep pace with the code. The higher trust among participants who used the agent on the code they knew least suggests that trust in AI can stand in for that model when it is missing. The knob here is how often the agent stops to report. At each stage, agents can state what they intend to change and why, and show which of their changes the developer has inspected in the code, which only in the app, and which not at all. When the report shows that the match has slipped, the developer can turn the other two knobs.

How far SSD can go depends on how these knobs are set. We hypothesize that the more agents a developer directs, the more knobs SSD requires: attenuation for a single agent, amplification as well for a small team, and all three for a swarm. Vibe coding promises that developers can forget the code exists. Our findings suggest that this does not hold today, even with one agent. To realize this promise and advance the vision of solo software development, where a single human directs a swarm of agents, we need designs grounded in the law of requisite variety—that absorb variety at the scale at which agents create it.

Acknowledgment

We thank OpenBCI for facilitating this project and the participants for their time. We also thank Annie Vella for an insightful conversation that helped shape the discussion of our findings.

References

  1. [1]A. Karpathy, “There’s a new kind of coding | call “vibe coding”,” Post on X, Feb. 20, 2025, posted February 2, 2025. [Online]. Available: https://x.com/karpathy/status/188619218480149383
  2. [2]V. Pimenova, S. Fakhoury, C. Bird, M.-A. Storey, and M. Endres, “Good vibrations? A qualitative study of co-creation, communication, flow, and trust in vibe coding,” arXiv preprint arXiv:2509.12491, 2025.arxiv.org/abs/2509.12491
  3. [3]J. Becker, N. Rush, E. Barnes, and D. Rein, “Measuring the impact of early-2025 AI on experienced open-source developer productivity,” arXiv preprint arXiv:2507.09089, 2025.arxiv.org/abs/2507.09089
  4. [4]T. Fritz, A. Begel, S. C. Müller, S. Yigit-Elliott, and M. Züger, “Using psycho-physiological measures to assess task difficulty in software development,” in Proceedings of the 36th International Conference on Software Engineering, 2014, pp. 402–413.DOI
  5. [5]N. Kosmyna, E. Hauptmann, Y. T. Yuan, J. Situ, X.-H. Liao, A. V. Beresnitzky, I. Braunstein, and P. Maes, “Your brain on ChatGPT: Accumulation of cognitive debt when using an AI assistant for essay writing task,” arXiv preprint arXiv:2506.08872, 2025.arxiv.org/abs/2506.08872
  6. [6]A. Sarkar and I. Drosos, “Vibe coding: Programming through conversation with artificial intelligence,” in Proceedings of the 36th Annual Conference of the Psychology of Programming Interest Group (PPIG 2025), 2025, arXiv:2506.23523. [Online]. Available: https://www.ppig.org/papers/2025-ppig-36th-sarkar/
  7. [7]R. Sapkota, K. I. Roumeliotis, and M. Karkee, “Vibe coding vs. agentic coding: Fundamentals and practical implications of agentic AI,” arXiv preprint arXiv:2505.19443, 2025.arxiv.org/abs/2505.19443
  8. [8]A. J. K. Abraham, L. Beckwith, A. Blackwell, M. Burnett, M. Erwig, C. Scaffidi, J. Lawrance, H. Lieberman, B. Myers, M. B. Rosson, G. Rothermel, M. Shaw, and S. Wiedenbeck, “The state of the art in end-user software engineering,” ACM Computing Surveys, vol. 43, no. 3, pp. 21:1–21:44, 2011.DOI
  9. [9]J. Medeiros, R. Couceiro, G. Duarte, J. Durães, J. Castelhano, C. Duarte, M. Castelo-Branco, H. Madeira, P. de Carvalho, and C. Teixeira, “Can EEG be adopted as a neuroscience reference for assessing software programmers’ cognitive load?” Sensors, vol. 21, no. 7, p. 2338, 2021.DOI
  10. [10]GitHub, “GitHub Copilot,” https://github.com/features/copilot, 2026, accessed: Oct. 29, 2026.
  11. [11]Anysphere, “Cursor,” https://cursor.com, 2026, accessed: Oct. 29, 2026.
  12. [12]J. A. Coan and J. J. B. Allen, “Frontal EEG asymmetry as a moderator and mediator of emotion,” Biological Psychology, vol. 67, no. 1–2, pp. 7–50, 2004.pubmed.ncbi.nlm.nih.gov/15130524
  13. [13]E. Harmon-Jones and P. A. Gable, “On the role of asymmetric frontal cortical activity in approach and withdrawal motivation: An updated review of the evidence,” Psychophysiology, vol. 55, no. 1, p. e12879, 2018.
  14. [14]A. Gevins and M. E. Smith, “Neurophysiological measures of cognitive workload during human-computer interaction,” Theoretical Issues in Ergonomics Science, vol. 4, no. 1–2, pp. 113–131, 2003.DOI
  15. [15]T. B. Sheridan, Telerobotics, Automation, and Human Supervisory Control. Cambridge, MA: MIT Press, 1992.
  16. [16]N. Yeung, C. B. Holroyd, and J. D. Cohen, “ERP correlates of feedback and reward processing in the presence and absence of response choice,” Cerebral Cortex, vol. 15, no. 5, pp. 535–544, 2005.pubmed.ncbi.nlm.nih.gov/15319308
  17. [17]P. Haggard, “Sense of agency in the human brain,” Nature Reviews Neuroscience, vol. 18, no. 4, pp. 196–207, 2017.DOI
  18. [18]G. H. E. Gendolla and M. Richter, “Effort mobilization when the self is involved: Some lessons from the cardiovascular system,” Review of General Psychology, vol. 14, no. 3, pp. 212–226, 2010.DOI
  19. [19]R. Parasuraman and D. H. Manzey, “Complexity and bias in human use of automation: An attentional integration,” Human Factors, vol. 52, no. 3, pp. 381–410, 2010.
  20. [20]S. Barke, M. B. James, and N. Polikarpova, “Grounded copilot: How programmers interact with code-generating models,” Proceedings of the ACM on Programming Languages, vol. 7, no. OOPSLA1, 2023.arxiv.org/abs/2206.15000
  21. [21]H. Mozannar, G. Bansal, A. Fourney, and E. Horvitz, “Reading between the lines: Modeling user behavior and costs in AI-assisted programming,” in Proceedings of the 2024 CHI Conference on Human Factors in Computing Systems, 2024.arxiv.org/abs/2210.14306
  22. [22]V. Chen, A. Talwalkar, R. Brennan, and G. Neubig, “Code with me or for me? how increasing ai automation transforms developer workflows,” in Proceedings of the 2026 CHI Conference on Human Factors in Computing Systems, ser. CHI ’26. New York, NY, USA: Association for Computing Machinery, 2026.
  23. [23]N. Tang, C. Chen, Z. Fang, G. Xu, M. Dhakal, Y. Shi, C. McMillan, Y. Huang, and T. J.-J. Li, “Programming by chat: A large-scale behavioral analysis of 11,579 real-world ai-assisted ide sessions,” in Proceedings of the 41st IEEE/ACM International Conference on Automated Software Engineering, ser. ASE ’26. New York, NY, USA: Association for Computing Machinery, 2026, pp. 588–600.DOI
  24. [24]Y.-H. Chou, B. Jiang, Y. W. Chen, M. Weng, V. Jackson, T. Zimmermann, and J. A. Jones, “Building software by rolling the dice: A qualitative study of vibe coding,” Proceedings of the ACM on Software Engineering, vol. 3, no. FSE, pp. 1712–1734, 2026.
  25. [25]R. Huang, A. Reyna, S. Lerner, H. Xia, and B. Hempel, “Professional software developers don’t vibe, they control: AI agent use for coding in 2025,” arXiv preprint arXiv:2512.14012, 2025.arxiv.org/abs/2512.14012
  26. [26]H. He, C. Miller, S. Agarwal, C. Kästner, and B. Vasilescu, “Speed at the cost of quality: How cursor ai increases short-term velocity and long-term complexity in open-source projects,” in Proceedings of the 23rd international conference on mining software repositories, 2026, pp. 181–193.DOI
  27. [27]N. Balneapur, C. Baumler, V. Chen, E. Choi, R. Rudinger, and J. L. Boyd-Graber, “(im) paired programming: Coding agents improve productivity but harm understanding,” arXiv preprint arXiv:2607.26375, 2026.
  28. [28]N. Perry, M. Srivastava, D. Kumar, and D. Boneh, “Do users write more insecure code with AI assistants?” in Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security, ser. CCS ’23. ACM, 2023, pp. 2785–2799.DOI
  29. [29]S. C. Müller and T. Fritz, “Stuck and frustrated or in flow and happy: Sensing developers’ emotions and progress,” in Proceedings of the 37th IEEE/ACM International Conference on Software Engineering, 2015, pp. 688–699.
  30. [30]M. T. Knierim, F. Stano, F. Kurz, A. Heusch, and M. L. Wilson, “Exploring flow in real-world knowledge work using discreet cEEGrid sensors,” in Proceedings of the 2025 CHI Conference on Human Factors in Computing Systems, ser. CHI ’25. ACM, 2025.arxiv.org/abs/2501.19217
  31. [31]N. Tang, M. Chen, Z. Ning, A. Bansal, Y. Huang, C. McMillan, and T. J.-J. Li, “Developer behaviors in validating and repairing llm-generated code using ide and eye tracking,” in Proceedings of the 2024 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC), 2024, pp. 40–46.DOI
  32. [32]Anonymous, “Supplemental Material for What EEG Reveals About Your Brain When Vibe Coding,” Oct. 2026. [Online]. Available: https://doi.org/10.5281/zenodo.23828529
  33. [33]OpenBCI, “Galea,” https://galea.co/, accessed: Oct. 29, 2026.
  34. [34]T. Harmony, T. Fernández, J. Silva, J. Bosch, P. Valdés, A. Fernández-Bouzas, L. Galán, E. Aubert, and D. Rodríguez, “Do specific EEG frequencies indicate different processes during mental calculation?” Neuroscience Letters, vol. 266, no. 1, pp. 25–28, 1999.pubmed.ncbi.nlm.nih.gov/10336175
  35. [35]R. J. Croft and R. J. Barry, “Removal of ocular artifact from the EEG: a review,” Neurophysiologie Clinique/Clinical Neurophysiology, vol. 30, no. 1, pp. 5–19, 2000.
  36. [36]R. J. Barry, A. R. Clarke, S. J. Johnstone, C. A. Magee, and J. A. Rushby, “EEG differences between eyes-closed and eyes-open resting conditions,” Clinical Neurophysiology, vol. 118, no. 12, pp. 2765–2773, 2007.pubmed.ncbi.nlm.nih.gov/17911042
  37. [37]R. R. Hoffman, S. T. Mueller, G. Klein, and J. Litman, “Measures for explainable AI: Explanation goodness, user satisfaction, mental models, curiosity, trust, and human-AI performance,” Frontiers in Computer Science, vol. 5, p. 1096257, 2023.DOI
  38. [38]R. Choudhuri, B. Trinkenreich, R. Pandita, E. Kalliamvakou, I. Steinmacher, M. Gerosa, C. Sanchez, and A. Sarma, “What guides our choices? modeling developers’ trust and behavioral intentions towards GenAI,” in Proceedings of the IEEE/ACM 47th International Conference on Software Engineering. IEEE, 2025.arxiv.org/abs/2409.04099
  39. [39]J. J. B. Allen, J. A. Coan, and M. Nazarian, “Issues and assumptions on the road from raw signals to metrics of frontal EEG asymmetry in emotion,” Biological Psychology, vol. 67, no. 1–2, pp. 183–218, 2004.pubmed.ncbi.nlm.nih.gov/15130531
  40. [40]R. Choudhuri, C. Bird, C. Badea, and A. Sarma, “To copilot and beyond: 22 AI systems developers want built,” arXiv preprint arXiv:2604.07830, 2026.arxiv.org/abs/2604.07830
  41. [41]A. Holm, K. Lukander, J. Korpela, M. Sallinen, and K. M. Müller, “Estimating brain load from the eeg,” The Scientific World Journal, vol. 9, no. 1, pp. 639–651, 2009.DOI
  42. [42]J. W. Tukey, Exploratory Data Analysis. Reading, MA: Addison-Wesley, 1977.
  43. [43]F. Wilcoxon, “Individual comparisons by ranking methods,” Biometrices Bulletin, vol. 1, no. 6, pp. 80–83, 1945.
  44. [44]D. S. Kerby, “The simple difference formula: An approach to teaching nonparametric correlation,” Comprehensive Psychology, vol. 3, p. 11.IT.3.1, 2014.DOI
  45. [45]J. Cohen, Statistical Power Analysis for the Behavioral Sciences, 2nd ed. Hillsdale, NJ: Lawrence Erlbaum Associates, 1988.
  46. [46]H. B. Mann and D. R. Whitney, “On a test of whether one of two random variables is stochastically larger than the other,” The Annals of Mathematical Statistics, vol. 18, no. 1, pp. 50–60, 1947.DOI
  47. [47]M. Hills and P. Armitage, “The two-period cross-over clinical trial,” British Journal of Clinical Pharmacology, vol. 8, no. 1, pp. 7–20, 1979.
  48. [48]Y. Benjamini and Y. Hochberg, “Controlling the false discovery rate: A practical and powerful approach to multiple testing,” Journal of the Royal Statistical Society: Series B (Methodological), vol. 57, no. 1, pp. 289–300, 1995.DOI
  49. [49]R. L. Wasserstein and N. A. Lazar, “The ASA statement on p-values: Context, process, and purpose,” The American Statistician, vol. 70, no. 2, pp. 129–133, 2016.
  50. [50]D. Nam, A. Macvean, V. Hellendoorn, B. Vasilescu, and B. Myers, “Using an LLM to help with code understanding,” in Proceedings of the IEEE/ACM 46th International Conference on Software Engineering, ser. ICSE ’24. ACM, 2024.arxiv.org/abs/2307.08177
  51. [51]J. Wacker, E. M. Mueller, D. A. Pizzagalli, J. Hennig, and G. Stemmler, “Dopamine-D2-receptor blockade reverses the association between trait approach motivation and frontal asymmetry in an approach-motivation context,” Psychological Science, vol. 24, no. 4, pp. 489–497, 2013.DOI
  52. [52]W. Schultz, P. Dayan, and P. R. Montague, “A neural substrate of prediction and reward,” Science, vol. 275, no. 5306, pp. 1593–1599, 1997.
  53. [53]C. D. Fiorillo, P. N. Tobler, and W. Schultz, “Discrete coding of reward probability and uncertainty by dopamine neurons,” Science, vol. 299, no. 5614, pp. 1898–1902, 2003.pubmed.ncbi.nlm.nih.gov/12649484
  54. [54]N. Pennington, “Stimulus structures and mental representations in expert comprehension of computer programs,” Cognitive Psychology, vol. 19, no. 3, pp. 295–341, 1987.DOI
  55. [55]M. R. Endsley and E. O. Kiris, “The out-of-the-loop performance problem and level of control in automation,” Human Factors, vol. 37, no. 2, pp. 381–394, 1995.DOI
  56. [56]K. J. K. Feng, D. W. McDonald, and A. X. Zhang, “Levels of autonomy for AI agents,” arXiv preprint arXiv:2506.12469, 2025.arxiv.org/abs/2506.12469
  57. [57]A. Vella, “The accidental rise of the supervisory engineer,” Talk at Agentic Engineering Day, Auckland, New Zealand, 2026, presented October 22, 2026. [Online]. Available: https://annievelma.com/files/agentic-engineering-day-auckland-october-2026-the-accidental-rise-of-the-supervisory-engineer.pdf
  58. [58]L. Bainbridge, “Ironies of automation,” in Analysis, design and evaluation of man–machine systems. Elsevier, 1983, pp. 129–135.
  59. [59]A. Simkute, L. Tankelevitch, V. Kewenig, A. E. Scott, A. Sellen, and S. Rintel, “Ironies of generative AI: Understanding and mitigating productivity loss in human-AI interaction,” International Journal of Human–Computer Interaction, vol. 41, no. 5, pp. 2898–2919, 2024.DOI
  60. [60]S. Passi and M. Vorvoreanu, “Overreliance on AI: Literature review,” Microsoft, Tech. Rep. MSR-TR-2022-12, 2022.
  61. [61]C. Qian, W. Liu, H. Liu, N. Chen, Y. Dang, J. Li, C. Yang, W. Chen, Y. Su, X. Cong, J. Xu, D. Li, Z. Liu, and M. Sun, “ChatDev: Communicative agents for software development,” in Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (ACL), 2024, pp. 15 174–15 186.arxiv.org/abs/2307.07924
  62. [62]S. Hong, M. Zhuge, J. Chen, X. Zheng, Y. Cheng, C. Zhang, J. Wang, Z. Wang, S. K. S. Yau, Z. Lin, L. Zhou, C. Ran, L. Xiao, C. Wu, and J. Schmidhuber, “MetaGPT: Meta programming for a multi-agent collaborative framework,” in International Conference on Learning Representations (ICLR), 2024.arxiv.org/abs/2308.00352
  63. [63]W. R. Ashby, An Introduction to Cybernetics. London: Chapman & Hall, 1956.
  64. [64]J. Brooks, Frederick P., The Mythical Man-Month: Essays on Software Engineering. Reading, MA: Addison-Wesley, 1975.
  65. [65]C. Chou, S. Y.-T. Lee, R. Choudhuri, and K.-L. Ma, “Vibe-GUIDE: A graph-based user interface in IDEs for oversight in vibe coding,” arXiv preprint arXiv:2609.23859, 2026.arxiv.org/abs/2609.23859
  66. [66]R. Parasuraman, T. B. Sheridan, and C. D. Wickens, “A model for types and levels of human interaction with automation,” IEEE Transactions on Systems, Man, and Cybernetics – Part A: Systems and Humans, vol. 30, no. 3, pp. 286–297, 2000.pubmed.ncbi.nlm.nih.gov/11760769
  67. [67]R. Choudhuri, C. Bird, C. Badea, M. Gerosa, and A. Sarma, “You shall not pass! Where and why developers draw the line on AI autonomy,” arXiv preprint arXiv:2607.00533, 2026. [Online]. Available: https://arxiv.org/abs/2607.00533
  68. [68]R. C. Conant and W. R. Ashby, “Every good regulator of a system must be a model of that system,” International Journal of Systems Science, vol. 1, no. 2, pp. 89–97, 1970.

Paper details

vlnc:W_k6qfvwpv
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Claude Opus 5.5 (bare), GPT-6

View statement
Looking for related papers…
Contents