1. Working with Agentic AI: Software Developer

How human skills and agentic skills are dynamically integrated and coordinated across software development responsibilities

1.1. Software Developer as an Occupation

A software developer researches, designs, codes, tests, and maintains computer software and applications to solve specific user needs and business problems. This occupation connects computer science, mathematical analysis, and engineering principles by transforming abstract requirements and logical models into functional, reliable, and scalable executable programs. While systems analysts focus primarily on high-level business processes and organizational architecture, and computer programmers focus strictly on translating provided specifications into code, the software developer owns a broader segment of the software development lifecycle (SDLC). To ensure that software solutions are robust and maintainable, the developer must understand how user requirements, algorithmic complexity, system constraints, security boundaries, and performance expectations collectively determine the viability and quality of the final application.

Typical responsibilities of a software developer include:

• software requirements analysis and system design;
• software coding, development, and implementation;
• software testing, debugging, and quality assurance;
• software maintenance, optimization, and upgrades;
• system integration and API development; and
• technical documentation and development lifecycle collaboration.

These responsibilities are fulfilled through distinct tasks and subtasks, each requiring one or more actions with specific skill requirements. Human skills and agentic skills both contribute to these responsibilities, but their levels and forms of involvement differ according to the responsibility, task, action, data, technical environment, and expected outcome.

1.2. Human Skills and Agentic Skills in Software Development

Software development increasingly integrates both human skills and agentic skills.

Human skills are reusable capabilities possessed and developed by software developers. They include algorithmic reasoning, architectural design, complex problem-solving, code readability judgment, edge-case anticipation, technical debt evaluation, system integration logic, and mentorship.

Agentic skills are reusable capabilities available to AI agents through their underlying models, contextual information, instructions, constraints, tools, and computational resources. In software development, these skills include code completion, boilerplate generation, syntax translation, static code analysis, unit test generation, refactoring suggestion, API schema formatting, and documentation drafting.

Both skill types contribute to the same occupational responsibilities, but their involvement varies by action. Formulating a novel algorithm to optimize a complex data-processing pipeline relies primarily on human knowledge of computational complexity and mathematical logic; an AI agent may then use agentic skills to generate the initial code scaffolding, suggest language-specific syntax optimizations, and write the corresponding unit tests. In system integration, the developer first determines the secure boundaries and data contracts between microservices, and an AI agent subsequently generates the client libraries and mocks the endpoints. Across these actions, human and agentic skills are activated sequentially or iteratively based on task requirements, with the human professional maintaining oversight and final judgment.

The relationship between these skills is not a fixed division where certain responsibilities permanently belong to humans and others to AI. Instead, human and agentic involvement shifts across tasks and between different actions within the same task.

1.3. Dynamic Human–Agentic Skill Integration and Collaboration in Software Development

Software development functions can be understood as an occupation where responsibilities are fulfilled through tasks and subtasks, tasks and subtasks are executed through actions, and actions require appropriate configurations of human and agentic skills.

An occupation provides the overall professional context. For software development, this context encompasses analyzing user needs, designing software architecture, writing and testing code, maintaining existing applications, and collaborating within engineering teams.

A responsibility represents an expected area of professional work or an outcome that the software developer accomplishes or maintains. Responsibilities such as system design, coding, testing, and maintenance each contain multiple tasks.

A task is a context-dependent unit of work used to fulfill part or all of a responsibility. When a task is too broad or complex for reliable execution, it is decomposed into smaller subtasks.

Tasks and subtasks are executed through one or more actions. Actions represent reusable and configurable operations such as writing a database query, implementing a sorting algorithm, generating a mock API response, running a static analysis tool, profiling memory usage, or drafting a pull request description.

Each action has skill requirements. These requirements describe the capabilities needed for effective and reliable execution. Depending on the action and its context, human skills, agentic skills, or an integration of both can satisfy these requirements.

The skills available for software development reside in a skill space containing both human skills and agentic skills. Relevant skills in this space can serve as candidate skills for executing the actions required by a particular task. A human skill in edge-case anticipation, for example, can serve as a candidate for identifying race conditions in a concurrent system, while an agentic skill in automated fuzzing can serve as a candidate for generating the randomized inputs required to test that concurrency model.

Candidate skills are evaluated relative to the requirements of the action and its occupational and task context. Appropriate skills are then selected and organized into a skill configuration for execution. Depending on these requirements, a configuration may rely mainly on human skills, mainly on agentic skills, or on an integrated arrangement of both.

1.3.1. Skills Competition and Skills Collaboration

Two important relationships can occur between human skills and agentic skills when constructing a skill configuration: skills competition and skills collaboration.

Skills competition occurs when both a human skill and an agentic skill can satisfy the same or similar requirements for an action, but simultaneous application of both is unnecessary. Under a particular occupational and task context, one skill type can provide a better fit for the action than the other.

For example, both a software developer and an AI agent can write standard CRUD (Create, Read, Update, Delete) functions for a new database table. When the schema, naming conventions, and framework patterns are clearly specified, the agentic skill provides fast and scalable execution. When the function requires implementing a highly customized, multi-step transactional rollback mechanism that depends on nuanced business logic, the developer’s human skills provide the necessary algorithmic reasoning and architectural judgment.

The purpose of skills competition is not to establish whether human or agentic skills are generally superior. Rather, it identifies which available skill provides the better fit for a particular action under particular conditions.

Skills collaboration occurs when one skill type alone cannot effectively satisfy the requirements of a task or its actions, or when combining complementary human and agentic skills produces stronger task performance.

Collaboration does not require human and agentic skills to operate simultaneously. Instead, they are activated at different stages of action execution in a sequential, iterative, or recursive manner according to evolving task requirements.

For example, a developer first designs the logical architecture for a new distributed caching layer and defines the expected data consistency models. An AI agent then generates the initial implementation code, scaffolds the integration tests, and runs static analysis to check for common concurrency flaws. The developer subsequently reviews the code and identifies a subtle logical flaw where a specific network partition scenario could lead to stale data reads. Based on the developer’s direction, the agent next rewrites the error-handling logic and generates new edge-case test scenarios. Finally, the developer evaluates the resulting implementation to ensure it is mathematically sound and operationally resilient. Throughout this sequence, human and agentic skills are activated iteratively as task requirements evolve, while the developer directs the implementation and evaluates its outcomes.

This dynamic relationship allows software developers to leverage the complementary strengths of both skill types rather than relying on a permanent allocation of work.

1.3.2. Skill Configuration and Task Execution

A skill configuration specifies which human skills and agentic skills are used to execute the actions associated with a task or subtask and how those skills are coordinated.

The configuration depends on factors such as action requirements, algorithmic complexity, security criticality, legacy code constraints, expected reliability, available development tools, performance thresholds, decision consequences, and intermediate results.

For one action, an agentic skill may independently satisfy the requirements. For another, a human skill may provide the better fit. A complex task may require several configurations across multiple actions, with human and agentic skills repeatedly interacting as the task progresses.

The configuration is therefore dynamic rather than permanent. It may change when the action changes, new security vulnerabilities are disclosed, an agentic result fails to satisfy expected performance benchmarks, or human interpretation identifies a more efficient algorithmic approach.

Throughout this process, the software developer remains the professional responsible for directing and controlling the work associated with the occupation and its responsibilities. Agentic AI provides powerful complementary capabilities that expand what the professional can generate, test, analyze, optimize, refactor, and document.

1.3.3. Task Performance Evaluation and Skill Space Adaptation

The performance produced through a selected skill configuration is evaluated against predefined evaluation metrics. These metrics determine whether the human skills, agentic skills, or their integrated configuration are sufficiently capable of performing the relevant task and its required actions.

Evaluation criteria depend on the work being performed. In software development, they include code correctness, execution efficiency, memory safety, test coverage, maintainability, security resilience, and adherence to architectural standards.

When a selected skill or skill configuration produces performance above the defined threshold, it passes the performance evaluation and is retained for future applications under appropriate conditions. Repeated successful use provides additional evidence about where that skill or configuration performs effectively.

When performance falls below the required threshold, the corresponding skill or configuration is not reused without modification. The relevant human or agentic skills may be refined or reconfigured, existing skills can be combined differently, or new human and agentic skills may be developed or constructed from scratch when the existing skill space lacks adequate capability.

For example, an AI agent first generates code to parse and validate large JSON payloads, but the resulting implementation repeatedly causes memory exhaustion when processing deeply nested structures. Task performance evaluation identifies this performance flaw as falling below the required threshold. The agentic skill is then refined through stricter streaming-parser instructions, memory-limit constraints, or integration with specialized validation libraries. The revised skill is evaluated again, and once it satisfies the required performance criteria, it is retained for appropriate future data-processing tasks. Human skills follow a corresponding development process: when a developer lacks the theoretical background required to implement a newly introduced cryptographic protocol, the relevant capability is developed through studying the literature and experimenting in sandbox environments before its performance is evaluated through subsequent production integrations.

Refined and newly constructed skills that satisfy the required performance criteria are added to the skill space. In this way, task performance evaluation provides feedback not only for completing current work but also for continuously optimizing and expanding the available skill space.

The skill space is not constructed as an isolated collection of occupation-specific representations. Many human and agentic skills used in software development are reusable across occupations. Algorithmic reasoning, code generation, static analysis, testing automation, technical writing, and system integration contribute to work in data engineering, DevOps, cybersecurity, embedded systems, and many other fields.

Reusable skills can therefore be represented once and configured differently according to the responsibilities, tasks, actions, and contexts of different occupations. This allows the skill space to serve a growing range of occupations without unnecessarily duplicating or exploding the number of skill representations. Occupational specialization is introduced through task context, action requirements, parameters, data sources, tools, constraints, and skill configurations rather than by creating a completely separate skill representation whenever the same underlying capability appears in another occupation.

The resulting process is adaptive: occupational responsibility → task and subtask → actions → skill requirements → candidate human and agentic skills → skill configuration → task execution → task performance evaluation → skill refinement, reconfiguration, or construction → optimized and expanded skill space

This cycle allows human and agentic capabilities to evolve alongside the requirements of software development work.

1.4. Essential Responsibilities of Software Developer

1.4.1. Software Requirements Analysis and System Design

Software requirements analysis and system design translates abstract user needs and business objectives into concrete technical specifications and architectural blueprints. This responsibility includes evaluating the feasibility of proposed features, designing data models, selecting appropriate design patterns, and defining the logical boundaries of software components.

Agentic skills contribute extensively to analyzing requirement documents for contradictions, generating initial database schemas, suggesting standard design patterns, and drafting boilerplate architectural diagrams. Human skills remain essential for understanding the nuanced business context, anticipating future scalability needs, resolving ambiguous user requests, and determining the optimal balance between system complexity and maintainability.

For example, a product team requests a new real-time notification feature for a web application. The software developer clarifies the expected message throughput and latency constraints. An AI agent then analyzes the requirements, proposes a publish-subscribe message broker architecture, and generates the initial data model for tracking delivery states. The developer reviews the proposal and identifies that the suggested broker introduces unacceptable operational overhead for the current scale of the application. The developer revises the design to utilize a simpler, server-sent events (SSE) approach, and the agent updates the technical specifications and schema definitions accordingly.

1.4.2. Software Coding, Development, and Implementation

Software coding, development, and implementation involves writing the actual executable instructions that realize the system design. This responsibility includes formulating complex algorithms, implementing business logic, managing application state, and ensuring code readability and adherence to team coding standards.

Agentic skills are well suited to intelligent code completion, boilerplate generation, syntax translation between languages, and suggesting localized refactoring improvements. Human skills contribute to high-level algorithmic problem-solving, ensuring the logical correctness of complex state transitions, managing technical debt, and writing code that is intuitive for other human developers to maintain.

For example, a developer is tasked with implementing a complex pricing engine that applies overlapping discount rules based on user history and inventory levels. An AI agent generates the standard object-oriented classes, database access layers, and basic conditional logic based on the developer’s pseudocode. The developer reviews the generated logic and realizes that the agent’s approach will result in exponential time complexity when processing large shopping carts. The developer redesigns the core evaluation algorithm using a more efficient rule-engine pattern, and the agent regenerates the affected code modules to match the new mathematical logic.

1.4.3. Software Testing, Debugging, and Quality Assurance

Software testing, debugging, and quality assurance verifies that the implemented code functions correctly, handles edge cases gracefully, and meets predefined performance and security standards. This responsibility includes writing unit and integration tests, reproducing reported defects, performing root-cause analysis, and utilizing static analysis tools.

Agentic skills assist with automated unit test generation, running static code analysis, identifying syntax errors, and executing fuzzing routines to discover unexpected inputs. Human skills are especially important for defining meaningful business edge cases, interpreting ambiguous bug reports from users, diagnosing complex race conditions or memory leaks, and determining the root cause of systemic logical failures.

For example, an automated testing pipeline flags a sporadic failure in the payment processing module. An AI agent analyzes the execution logs, identifies the exact line of code where the thread deadlocks, and generates a draft patch to introduce a mutex lock. The developer reviews the agent’s diagnosis and recognizes that applying a simple lock will severely degrade the system’s throughput during peak traffic. Instead, the developer redesigns the transaction queue to handle the concurrency asynchronously, and the agent updates the integration tests to verify the new asynchronous behavior under heavy load.

1.4.4. Software Maintenance, Optimization, and Upgrades

Software maintenance, optimization, and upgrades ensures that existing applications remain secure, performant, and compatible with evolving environments. This responsibility includes profiling code for bottlenecks, updating deprecated dependencies, refactoring legacy code, and adapting software to run on new hardware or operating systems.

Agentic skills contribute to continuous dependency scanning, identifying deprecated API calls, profiling memory and CPU usage, and suggesting localized performance optimizations. Human skills evaluate the broader impact of upgrading core libraries, decide when legacy code requires a complete rewrite versus incremental refactoring, and understand the historical business logic embedded in older systems that lacks formal documentation.

For example, an enterprise application experiences gradual performance degradation over time. An AI agent profiles the application, identifies several memory leaks associated with a specific third-party caching library, and drafts a script to update the library to its latest version. The developer reviews the proposed upgrade and realizes that the new library version introduces breaking changes to the serialization format that will corrupt existing user sessions. The developer designs a backward-compatible adapter pattern to bridge the old and new formats, and the agent implements the adapter code and generates regression tests to ensure data integrity.

1.4.5. System Integration and API Development

System integration and API development connects distinct software components, external services, and databases into a cohesive ecosystem. This responsibility includes designing secure data contracts, implementing RESTful or GraphQL endpoints, handling distributed system failures, and managing authentication and authorization flows.

Agentic skills retrieve external API documentation, generate client SDKs, format JSON/XML schemas, mock endpoints for local testing, and write boilerplate authentication middleware. Human skills define the security boundaries of the integration, design resilient retry and fallback mechanisms for network failures, and ensure that data contracts strictly enforce privacy and compliance requirements.

For example, a development team needs to integrate their application with a new, third-party identity provider. An AI agent ingests the provider’s extensive OpenAPI specification, generates the necessary client models, and scaffolds the OAuth2 authentication flow. The developer reviews the generated integration and identifies that the default token refresh logic will fail silently if the user’s device loses network connectivity during the handshake. The developer designs a robust, localized state-machine to handle offline token queuing, and the agent updates the integration code to implement this resilient error-handling logic.

1.4.6. Technical Documentation and Development Lifecycle Collaboration

Technical documentation and development lifecycle collaboration ensures that software decisions are transparent, reproducible, and accessible to the broader engineering team. This responsibility includes writing architectural decision records, conducting peer code reviews, drafting release notes, and mentoring junior developers.

Agentic skills assist with generating inline code comments, summarizing complex pull requests, drafting initial release notes from commit histories, and checking documentation for broken links or outdated references. Human skills evaluate the clarity and architectural significance of the documentation, provide constructive and context-aware feedback during code reviews, and transfer tacit engineering knowledge to team members.

For example, a developer submits a massive pull request that fundamentally alters the application’s database routing logic. An AI agent analyzes the diff, generates a structured summary of the changed files, and flags potential SQL injection vulnerabilities in the new routing queries. The developer leading the code review reads the agent’s summary but recognizes that while the code is technically secure, the new routing logic violates the team’s established domain-driven design boundaries, which will make future feature development significantly harder. The developer provides targeted feedback requesting a structural refactor, and the agent assists the original author by suggesting specific file reorganizations to satisfy the architectural review.

1.5. Changing Human and Agentic Involvement Across Software Developer Responsibilities

Human skills and agentic skills are involved throughout software development, but their relative involvement differs across responsibilities and changes during task execution.

These involvement levels are not permanent allocations. A single responsibility may contain actions where human and agentic skills compete as alternative capabilities and other actions where they collaborate sequentially, iteratively, or recursively.

The practical objective is to construct skill configurations that use the most suitable available capabilities for each part of the work and revise those configurations when task performance evaluation shows that another arrangement performs more effectively or reliably.

1.6. Working as a Software Developer with Agentic AI

Agentic AI is becoming an increasingly powerful component of software development. Software developers should therefore adopt and integrate AI agents as complementary participants in professional workflows rather than treating them only as occasional tools for generating boilerplate code, formatting schemas, or drafting documentation.

This shift does not reduce the importance of computer science fundamentals, algorithmic reasoning, and architectural expertise. Human professionals remain responsible for the occupation and its corresponding responsibilities. They understand user needs, design logical architectures, formulate complex algorithms, evaluate technical debt, diagnose systemic failures, communicate with engineering teams, control consequential production deployments, evaluate task performance, and decide how human and agentic skills are configured and improved.

At the same time, agentic skills greatly expand the volume and complexity of development work that can be executed. AI agents ingest massive technical specifications, generate and refactor thousands of lines of code, execute exhaustive static analyses, automate complex testing pipelines, profile system performance, and synthesize extensive technical documentation at a scale difficult to achieve through direct human effort alone.

Strong software development practice is therefore not based on maximizing human work or agentic work independently. It is based on finding appropriate configurations of human skills and agentic skills for the responsibilities, tasks, subtasks, and actions being performed.

Where a human skill and an agentic skill can independently perform the same action, skills competition identifies which is better suited to the current context. Where work requires complementary capabilities, skills collaboration results in human and agentic skills being activated sequentially, iteratively, or recursively to achieve stronger task performance than either skill type achieves alone.

Task performance evaluation then determines whether selected skills and configurations satisfy predefined expectations. Successful skills are retained and reused, while inadequate skills are refined, reconfigured, or newly developed. The resulting capabilities return to an increasingly useful skill space that supports software development and, where capabilities are reusable, other occupations as well.

For a software developer, working effectively with agentic AI means treating AI as a powerful complementary capability integrated into everyday professional routines while maintaining human control of occupational responsibilities. Through appropriate skill selection, competition, collaboration, evaluation, and continuous improvement, human professionals and agentic AI work together to achieve software solutions that are more efficient, scalable, secure, adaptable, timely, and fundamentally robust.