Working with Agentic AI: Generative AI Software Engineer
1. Working with Agentic AI: Generative AI Software Engineer
How Human Skills and Agentic Skills Dynamically Combine Across Generative AI Software Engineering Responsibilities
1.1. Generative AI Software Engineering as Professional Work
A generative AI software engineer designs, develops, evaluates, deploys, maintains, and improves software systems that use generative AI models to produce, transform, retrieve, reason over, or interact with information. The work can include building applications around large language models and other generative models, developing retrieval-augmented generation systems, constructing agentic workflows, designing prompts and model interactions, integrating external data and tools, implementing application logic, evaluating generated outputs, and operating generative AI capabilities in production. Generative AI software engineers also build the software infrastructure surrounding models, connect AI components with applications and services, establish testing and observability, investigate failures, optimize quality, latency, reliability, and computational cost, and adapt systems as models and application requirements change. Because application behavior emerges from interactions among models, instructions, retrieved context, tools, software components, data, and users, effective generative AI engineering requires understanding the complete system rather than treating the underlying model as an isolated component. The work consequently combines software engineering, AI and machine learning knowledge, experimentation, systems thinking, data reasoning, evaluation, problem solving, and technical judgment to create generative AI applications that are useful, reliable, scalable, maintainable, and appropriate for their intended purposes.
1.2. Human Skills, Agentic Skills, and Their Integration
Human skills are particularly important when generative AI software engineering requires problem formulation, architecture, interpretation of application requirements, experimental judgment, evaluation of open-ended behavior, or decisions about acceptable system performance and risk. Software engineering knowledge, understanding of generative models, systems thinking, data reasoning, analytical problem solving, and technical judgment allow an engineer to translate practical needs into application designs, select suitable model and system approaches, interpret unexpected outputs, identify weaknesses in retrieval or orchestration, and balance quality with latency, reliability, maintainability, security, and cost. These capabilities become especially important because generative AI behavior is probabilistic and context-dependent: an output can appear plausible while being incomplete, unsupported, inappropriate, or inconsistent with the application’s intended behavior.
At the same time, agentic skills can participate extensively in the engineering process itself. Agentic AI can inspect requirements, code, documentation, traces, datasets, prompts, evaluation results, and system configurations; generate or revise software; construct tests; explore candidate implementations; execute defined experiments through authorized tools; compare model outputs; analyze failure patterns; and assist with debugging, deployment, and monitoring. An agent may also use development environments, repositories, APIs, databases, retrieval systems, testing frameworks, and infrastructure tools when appropriately authorized. This ability to reason over technical context and act through tools can accelerate iterative software development and expand the number of alternatives, tests, and diagnostic paths that can be explored.
Generative AI software engineering can therefore involve a particularly close integration of human skills and agentic skills across responsibilities, tasks, and subtasks. An engineer might define an application’s intended behavior and architectural constraints while Agentic AI develops a candidate implementation and evaluation suite. Test results may reveal a retrieval problem that requires human reinterpretation of the system design, after which an agent modifies the pipeline and performs another evaluation cycle. In another workflow, agentic analysis may identify an unexpected interaction among prompts, context, tools, and application logic that changes what needs to be investigated. Human and agentic contributions can consequently shift as requirements, evidence, system behavior, and operational conditions develop.
1.3. Dynamic Allocation of Tasks and Subtasks
Generative AI software engineering responsibilities contain tasks and subtasks with markedly different capability requirements. Allocation should therefore begin with what a particular subtask requires, rather than with a fixed assumption that software design is human work while implementation or automation is agentic work. Building a generative AI application, for example, may involve defining the use case, selecting models, designing application architecture, preparing knowledge sources, constructing retrieval, developing prompts, implementing orchestration, integrating tools and APIs, generating application code, creating evaluation datasets, testing outputs, analyzing failures, deploying services, monitoring production behavior, and improving the system. Each subtask may call for a different combination of contextual interpretation, coding, experimentation, information processing, tool use, evaluation, and engineering judgment.
A practical allocation begins by decomposing the work into meaningful subtasks and identifying their capability requirements. The generative AI software engineer, Agentic AI, or both may establish objectives, constraints, available information, evaluation requirements, software dependencies, model capabilities, tool permissions, and expected outputs. A defined comparison of several model or prompt configurations may support extensive agentic execution because alternatives can be generated, tested, and measured systematically. Deciding whether the resulting behavioral differences are acceptable for the application’s intended users may require greater human contextual understanding. The appropriate skill configuration therefore depends on the nature of the subtask rather than on a permanent division between engineering and AI work.
Execution itself generates new information. Intermediate results can therefore change the allocation of subsequent work. Agentic testing may discover that a quality problem originates in retrieval rather than generation, shifting the next subtask toward retrieval analysis. Human examination may reveal that the underlying issue is an incorrectly formulated requirement, after which agentic implementation can proceed under revised constraints. A tool-using agent may encounter an unexpected API response that requires human architectural judgment, while a clarified design can subsequently return coding, testing, and validation to agentic execution.
A useful representation of this process is:
Responsibility → Task → Subtask → Capability Requirements → Human and/or Agentic Skills → Execution → Evaluation → Possible Reallocation
Generative AI development is inherently iterative, and the availability of agentic engineering capabilities makes the allocation of work similarly dynamic rather than fixed. Human and agentic skills can be selected, combined, evaluated, and reassigned as application requirements, experimental evidence, model behavior, and production conditions change.
1.4. Generative AI Software Engineering Responsibilities
1.4.1. Generative AI Problem Formulation and Solution Architecture
A successful generative AI application begins with determining what problem the system should address and whether generative AI provides an appropriate solution. User needs, expected outputs, available information, software dependencies, model capabilities, performance requirements, operational constraints, and acceptable failure conditions all influence the resulting architecture. Human skills are central to interpreting these factors and deciding how generative capabilities should fit within a broader software system. Agentic analysis can support this reasoning by synthesizing requirements, investigating relevant technical approaches, comparing model and architectural alternatives, identifying dependencies, and exposing assumptions or unresolved questions. Candidate architectures can then become inputs to human engineering judgment, with revised decisions initiating further agentic exploration when necessary.
| Human Skills | Agentic Skills | Dynamic Human–Agentic Interaction |
|---|---|---|
| Interpret application needs, formulate appropriate generative AI problems, define intended behavior and constraints, and make architectural trade-offs. | Synthesize technical requirements, investigate candidate approaches, compare architectural alternatives, identify dependencies, and expose unresolved assumptions. | Human-defined objectives establish the direction of agentic architectural exploration; resulting alternatives and constraints support human design decisions and can initiate further analysis or refinement. |
1.4.2. Model Selection, Prompting, and Generative Behavior Design
Generative behavior depends on more than choosing a capable model. Model characteristics, system instructions, prompts, context construction, sampling or inference settings, structured outputs, conversation state, and surrounding application logic can all influence what the system produces. Agentic skills can systematically compare models, generate and revise prompt alternatives, execute defined experiments, analyze output patterns, and explore configuration combinations at a scale that would be difficult to examine manually. Human judgment determines what constitutes useful or appropriate behavior, which differences matter for the application, and when prompt-level adjustments are insufficient to solve a deeper architectural or data problem. Model and interaction design can therefore proceed as an iterative process in which agentic experimentation expands the evidence available for human technical decisions.
| Human Skills | Agentic Skills | Dynamic Human–Agentic Interaction |
|---|---|---|
| Define intended model behavior, interpret qualitative differences, judge application relevance, and determine when problems require changes beyond prompting or configuration. | Compare candidate models and configurations, generate prompt variants, execute behavioral experiments, and analyze recurring output characteristics. | Agentic experimentation explores the model-behavior space within human-defined objectives; human evaluation interprets the resulting differences and redirects subsequent model, prompt, or architectural refinement. |
1.4.3. Retrieval, Context, and Knowledge Integration
Generative AI applications often need information beyond what a model contains internally. Retrieval-augmented generation and related approaches can connect models with documents, databases, search systems, knowledge stores, or other authorized information sources, but the quality of the resulting output depends on how information is prepared, retrieved, ranked, assembled, and supplied as context. Agentic skills can analyze source material, assist with data preparation, generate retrieval logic, compare chunking or indexing strategies, test queries, evaluate retrieved evidence, and identify cases in which relevant information is missing or poorly ranked. Human understanding remains important for determining which sources are authoritative, what information the application should be permitted to use, how retrieval quality relates to actual user needs, and whether observed failures originate in retrieval, context construction, generation, or the underlying knowledge itself.
| Human Skills | Agentic Skills | Dynamic Human–Agentic Interaction |
|---|---|---|
| Determine appropriate knowledge sources, interpret information requirements, establish relevance and access boundaries, and diagnose context-related limitations. | Prepare and analyze retrieval content, develop retrieval procedures, compare retrieval strategies, evaluate returned evidence, and identify missing or weak context. | Agentic retrieval analysis reveals how information reaches the model; human interpretation determines whether that information is appropriate and sufficient, with revised retrieval decisions directing further agentic testing and optimization. |
1.4.4. Agentic Workflow, Tool Use, and Orchestration Engineering
Some generative AI applications extend beyond producing a single response and instead coordinate multiple reasoning steps, tools, APIs, retrieval operations, software functions, or specialized agents. Designing these workflows requires decisions about task decomposition, state, sequencing, tool selection, permissions, recovery, fallback behavior, and termination conditions. Agentic AI can help generate orchestration logic, implement tool interfaces, simulate workflow paths, test alternative decompositions, inspect traces, and identify recurring failure patterns. Yet greater autonomy also creates more possible interactions and failure modes. Human systems thinking is therefore particularly important for determining which actions should be available, establishing operational boundaries, anticipating unintended behavior, and deciding when the system should continue autonomously, request clarification, fall back to another procedure, or transfer control to a person.
| Human Skills | Agentic Skills | Dynamic Human–Agentic Interaction |
|---|---|---|
| Design workflow boundaries, determine appropriate autonomy, define tool permissions and recovery behavior, anticipate failure modes, and judge consequential actions. | Develop orchestration logic and tool integrations, test workflow paths, analyze execution traces, explore task decompositions, and refine defined agent behaviors. | Human-defined goals, permissions, and safeguards establish the operating space; agentic implementation and testing expose actual workflow behavior, with failures or unexpected interactions triggering human reassessment or further agentic refinement. |
1.4.5. Generative AI Application and Software Development
A generative AI capability must ultimately operate as part of a functioning software system. Application services, APIs, user interfaces, backend logic, data flows, authentication, persistence, model interfaces, asynchronous processes, error handling, and surrounding software components may all need to be developed and integrated. Agentic skills can contribute extensively through code generation, refactoring, test creation, dependency analysis, debugging, documentation, and interaction with authorized development tools. Software engineering judgment remains necessary for architecture, maintainability, interface design, security boundaries, failure handling, and decisions whose consequences extend across the system. Development can consequently move rapidly between agentic implementation and human review, with test results and integration behavior determining where the next engineering effort is required.
| Human Skills | Agentic Skills | Dynamic Human–Agentic Interaction |
|---|---|---|
| Define software architecture, maintain design intent, evaluate system-wide trade-offs, establish interfaces and boundaries, and judge consequential implementation decisions. | Generate and revise code, develop tests, inspect dependencies, diagnose implementation problems, refactor components, and support software documentation. | Human architectural intent provides constraints for agentic software development; implementation and test results reveal new issues or alternatives that may be resolved agentically or returned to human engineering judgment. |
1.4.6. Evaluation, Testing, Safety, and Quality Engineering
Open-ended generative outputs make evaluation fundamentally different from checking whether a deterministic software function returned one predefined answer. Quality may involve factuality, groundedness, relevance, completeness, instruction following, safety, robustness, latency, cost, or other application-specific criteria, and improvements in one dimension can affect another. Human skills are important for defining what quality means, constructing representative evaluation cases, interpreting ambiguous outcomes, and determining which failures are consequential. Agentic skills can scale this process by generating tests, executing evaluation suites, applying automated or model-based evaluators, comparing system variants, clustering failure patterns, and tracing problems across system components. Evaluation therefore becomes both an engineering activity and a continuing feedback mechanism through which evidence can redirect retrieval, prompts, orchestration, software, model selection, or application requirements.
| Human Skills | Agentic Skills | Dynamic Human–Agentic Interaction |
|---|---|---|
| Define meaningful quality and safety criteria, establish representative evaluation conditions, interpret ambiguous results, and determine the significance of failures and trade-offs. | Generate and execute evaluation cases, apply scalable evaluators, compare variants, analyze failure patterns, and trace quality problems across system components. | Agentic evaluation expands the breadth and frequency of testing; human judgment establishes the meaning of the evidence and redirects subsequent system changes, which can then be evaluated through another agentic cycle. |
1.4.7. Deployment, Observability, Reliability, and Lifecycle Optimization
Production generative AI systems must continue to perform under changing users, inputs, models, knowledge sources, dependencies, workloads, and infrastructure conditions. Quality, latency, availability, token or computational usage, cost, retrieval behavior, tool execution, errors, and end-to-end traces may therefore need continuous observation. Agentic skills can analyze large volumes of operational evidence, detect behavioral changes, correlate failures across components, investigate traces, identify recurring problems, and assist with optimization or remediation. Human judgment becomes especially important when an operational signal has several plausible causes or when a proposed change affects user experience, reliability, security, cost, or system architecture. Production operation thus forms a continuing feedback loop in which monitoring evidence drives diagnosis, corrective action, re-evaluation, and further system improvement.
| Human Skills | Agentic Skills | Dynamic Human–Agentic Interaction |
|---|---|---|
| Define operational requirements, interpret production behavior, prioritize reliability and cost trade-offs, diagnose ambiguous failures, and determine appropriate corrective actions. | Monitor quality and system indicators, analyze traces and usage patterns, correlate operational evidence, detect anomalies, and investigate candidate causes or optimizations. | Continuous agentic analysis surfaces changing conditions and failures; human interpretation determines their operational significance, after which remediation, testing, or optimization may again proceed through agentic workflows. |
1.4.8. Technical Collaboration, Reusable Engineering, and Generative AI Knowledge Development
Generative AI software engineering develops rapidly and rarely occurs in isolation. Engineers collaborate with software, machine learning, data, infrastructure, security, product, design, domain, and other specialists while also maintaining reusable code, evaluation tools, development patterns, documentation, and technical knowledge. Agentic skills can preserve context across engineering work, summarize experiments and decisions, generate documentation, support code and test review, identify reusable patterns, retrieve technical information, and compare emerging models, frameworks, and engineering approaches. Human communication and technical judgment determine how this information should influence shared architecture, development standards, product decisions, and future technical direction. Knowledge generated through individual projects can consequently feed back into reusable engineering practices rather than remaining confined to isolated implementations.
| Human Skills | Agentic Skills | Dynamic Human–Agentic Interaction |
|---|---|---|
| Coordinate across specialties, communicate technical meaning, preserve engineering intent, evaluate emerging approaches, mentor others, and determine which patterns should become reusable practices. | Maintain technical context, summarize experiments and decisions, support code and documentation development, identify recurring patterns, and retrieve or compare relevant technical knowledge. | Agentic knowledge and engineering support connects information across projects and development cycles; human judgment determines what should be generalized, communicated, adopted, or revised, creating new context for subsequent agentic work. |
1.5. Human–Agentic Involvement Across Generative AI Software Engineering
The relative involvement of human and agentic skills differs among responsibilities and among the tasks within each responsibility. The following matrix therefore represents common tendencies rather than fixed assignments.
| Responsibility | Typical Human Involvement | Typical Agentic Involvement | Common Interaction Pattern |
|---|---|---|---|
| Generative AI Problem Formulation and Solution Architecture | Very High | High | Human problem formulation and architectural judgment supported by agentic requirements synthesis and solution exploration |
| Model Selection, Prompting, and Generative Behavior Design | Very High | Very High | Human definition and interpretation of intended behavior combined with agentic experimentation across models, prompts, and configurations |
| Retrieval, Context, and Knowledge Integration | High | Very High | Agentic retrieval development and analysis guided by human judgments about information relevance, authority, and application context |
| Agentic Workflow, Tool Use, and Orchestration Engineering | Very High | Very High | Agentic workflow implementation and testing within human-defined goals, permissions, safeguards, and autonomy boundaries |
| Generative AI Application and Software Development | High | Very High | Agentic coding, testing, and debugging combined with human software architecture and system-level engineering judgment |
| Evaluation, Testing, Safety, and Quality Engineering | Very High | Very High | Scalable agentic evaluation combined with human definition and interpretation of quality, safety, failures, and trade-offs |
| Deployment, Observability, Reliability, and Lifecycle Optimization | High | Very High | Continuous agentic operational analysis with human diagnosis, prioritization, and consequential production decisions |
| Technical Collaboration, Reusable Engineering, and Generative AI Knowledge Development | Very High | High | Agentic engineering and knowledge support combined with human communication, coordination, technical leadership, and judgment |
1.6. Why the Division of Work Changes
No single division of human and agentic work is appropriate across generative AI software engineering. Activities involving extensive code generation, systematic experimentation, information processing, repeated evaluation, trace analysis, or continuous monitoring may support substantial agentic involvement. Greater human participation becomes important when work requires ambiguous problem formulation, architecture, interpretation of open-ended behavior, consequential system changes, security or safety judgment, coordination among stakeholders, or professional accountability. The appropriate allocation can also change rapidly because generative AI applications combine probabilistic models with deterministic software, external information, tools, and changing operational conditions.
| Allocation Factor | Effect on Human–Agentic Work |
|---|---|
| Problem ambiguity | Unclear application objectives or uncertain relationships between user needs and generative capabilities increase the need for human interpretation and problem formulation. |
| Model capability and behavior | More capable models can expand agentic engineering and application possibilities, while unpredictable or poorly understood behavior increases requirements for evaluation and human judgment. |
| Context and knowledge quality | Accurate, relevant, well-structured context can support more reliable agentic behavior, whereas incomplete, conflicting, outdated, or poorly retrieved information requires stronger human analysis. |
| Evaluation clarity | Well-defined quality criteria and representative evaluation data permit more systematic agentic testing, while subjective or context-dependent outcomes require greater human interpretation. |
| Workflow complexity | Multi-step reasoning, tool use, retrieval, memory, and interactions among agents increase both the value of agentic execution and the need for human systems-level reasoning. |
| Model capability for engineering work | Greater reasoning, coding, information-processing, and tool-use capabilities expand the range of software engineering subtasks that Agentic AI can perform. |
| Agentic skill availability | Specialized skills for coding, retrieval, evaluation, orchestration, testing, deployment, monitoring, and debugging determine which engineering activities can be delegated effectively. |
| Tool access | Authorized access to repositories, development environments, APIs, databases, model services, evaluation systems, cloud platforms, and observability tools expands what an agent can inspect or execute. |
| Output reliability | Incorrect code, unsupported reasoning, misleading evaluations, unsafe actions, or unreliable diagnoses require human review, further testing, or reassignment. |
| Intermediate results | Test failures, model outputs, retrieval evidence, execution traces, user feedback, and production observations may change both the problem being solved and the capabilities required next. |
| Application consequence | Systems whose outputs or actions can materially affect users, operations, or other systems require stronger human validation and controlled execution. |
| Autonomy and tool permissions | The ability of a generative AI system to call tools, modify data, execute actions, or coordinate other agents increases the importance of explicit boundaries and human oversight. |
| Security and data sensitivity | Sensitive information, privileged tools, external data access, or security-relevant workflows require stronger access controls, validation, and human judgment. |
| Latency and cost constraints | Strict performance or cost requirements may change model, retrieval, orchestration, and infrastructure choices and therefore alter which optimization subtasks are most suitable for agentic execution. |
| Automation safeguards | Testing, sandboxing, approvals, versioning, rollback, access restrictions, fallback procedures, and monitoring determine how independently agentic engineering or operational actions may proceed. |
| Organizational policy | Software standards, AI governance, security requirements, data policies, release procedures, and approval processes may restrict or condition agentic actions. |
| Authority and accountability | Agentic capability does not itself provide authority to define consequential product behavior, approve production releases, accept safety or security risk, change governance requirements, or assume accountability for system outcomes. |
Several factors may influence the same task simultaneously. Agentic AI might execute a large evaluation suite and identify that a generative application produces high-quality responses in most cases but becomes unreliable when retrieval returns conflicting evidence. Automated analysis can further isolate the affected patterns, yet determining the acceptable behavior under such ambiguity may depend on the application’s purpose and consequences. Human judgment can establish a revised requirement or fallback policy, after which Agentic AI can modify the implementation, rerun the evaluation suite, and analyze the resulting behavior. The division of work therefore changes with both the original engineering problem and the evidence produced while solving it.
1.7. Developing Generative AI Software Engineering Capability with Agentic AI
Greater access to agentic skills does not reduce the importance of generative AI software engineering expertise. Software engineering, understanding of generative models, data and retrieval knowledge, systems thinking, experimentation, evaluation, debugging, security awareness, and technical judgment allow an engineer to understand why a generative AI system behaves as it does, distinguish model limitations from software or context problems, evaluate competing architectures, and recognize when an apparently successful output conceals a deeper system weakness.
Professional capability increasingly also includes knowing how to engineer with agentic capabilities. A generative AI software engineer may need to define objectives and constraints for coding or analytical agents, provide appropriate repository and system context, connect authorized tools, evaluate generated implementations, recognize unsupported assumptions, request additional experiments, establish execution safeguards, inspect agent traces, and determine when a subtask should shift back to direct human control. The engineer therefore develops both the ability to build generative AI systems and the ability to coordinate how engineering work is distributed across human and agentic capabilities.
This creates a broader model of professional capability:
Professional Capability = Human Skills + Agentic Skills + Human–Agentic Coordination
The relative contribution of these components will differ across applications, engineering responsibilities, and production environments. It will also continue to change as generative models, reasoning capabilities, agentic skills, software frameworks, evaluation methods, retrieval technologies, tool interfaces, and infrastructure evolve.
1.8. The Evolving Boundary Between Human and Agentic Skills
A generative AI software engineer and Agentic AI are better understood through an adaptive division of work than through a permanent separation between human tasks and AI tasks. Agentic skills may perform substantial portions of code generation, testing, retrieval development, prompt experimentation, model comparison, evaluation, debugging, trace analysis, documentation, deployment preparation, monitoring, and technical information retrieval. Human skills remain especially important when engineering requires ambiguous problem formulation, architectural judgment, interpretation of open-ended model behavior, definition of acceptable quality, autonomy decisions, security or safety evaluation, cross-functional coordination, or decisions whose consequences cannot be determined from technical metrics alone.
The boundary can move repeatedly within a single development workflow. An engineer may define an application’s intended behavior and establish its architectural constraints; Agentic AI may develop the initial retrieval and orchestration implementation; evaluation may reveal that the system answers accurately when evidence is clear but behaves inconsistently when retrieved sources conflict. Human analysis may then establish how conflicting evidence should be handled, after which the agent modifies the workflow, develops additional tests, executes them, and analyzes the results. Production behavior can begin another cycle when real user interactions expose conditions that were not represented during development. Each intermediate result changes the state of the engineering problem and may therefore change the most appropriate combination of skills for the next subtask.
The longer-term value of Agentic AI in generative AI software engineering consequently extends beyond accelerating coding or generating application content. It expands the analytical, generative, coding, testing, and operational capabilities available throughout the software lifecycle and allows those capabilities to be selected, combined, evaluated, and reallocated as requirements, models, evidence, and operating conditions change. Effective human–agentic coordination can increase development speed, broaden experimentation, strengthen evaluation, improve software quality, accelerate troubleshooting, expand observability, and support more systematic lifecycle improvement. At the same time, human problem formulation, systems thinking, contextual interpretation, communication, architectural judgment, risk evaluation, and professional accountability remain essential for determining what generative AI systems should do, how much autonomy they should have, and whether their behavior is appropriate within the environments in which they operate.