Agentic Software Engineer (.NET, Azure, Full-Stack)

*Agentic Software Engineer (.NET, Azure, Full-Stack)* ArchitectNow | Remote (US) | $120,000 to $150,000 base + benefits *About this role* ArchitectNow builds software through a spec driven, agentic process. Every feature begins as a specification with defined acceptance criteria and architectural constraints; AI agents generate most of the code from it, and the developer who owns the specification reviews, tests, and delivers the result. The primary output of this role is requirements, specifications, and architecture rather than hand-written code. This approach depends on real engineering depth. Several years of delivering production .NET and Angular, React, or Blazor applications on Azure are required, because that experience is what makes specifications implementable, architecture sound, and review of generated code reliable. Candidates should already be working this way in production. We are not able to train for agentic, spec driven development in this role. This practice is further along at ArchitectNow than at most organizations. Every developer on our team works this way today: spec driven development with agentic implementation is the standard on every project, not a pilot. It is also still evolving, here and across the industry, and we learn, optimize, and pivot quickly to keep the quality of what we deliver extremely high. We are looking for someone who wants to work at the leading edge of software development and to help shape how we do it: evaluating new tools as they arrive, improving our spec templates, skills, and agents, and contributing to the processes the rest of the team adopts. *About ArchitectNow* For 18 years, ArchitectNow has helped businesses ship software that does the work. We are a Microsoft Solutions Partner with active designations in Digital & App Innovation (Azure), Data & AI (Azure), and Infrastructure (Azure). Across cloud-native applications, AI, data platforms, the Power Platform, and the managed cloud services that keep production running, our focus has always been getting hard things built, well, and on time. What has changed is how we build. We have moved our delivery practice to spec driven development (currently GitHub Spec Kit) and agentic implementation. Our team standardizes on Claude Code, but the skill we hire for is agentic development itself, whatever framework or model you have practiced it with. Our engineers spend their time on requirements, specifications, architecture, review, and client outcomes, and let agents do the typing. The work itself is varied: polished, UI-heavy web applications; agents and AI features built into client systems; and data and AI platform projects on Microsoft Fabric, Purview, and AI Foundry. We are fully remote across 14 states, small enough that your work is visible to leadership the same week you do it, and there are no layers between an engineer and the client by design. *How we build* Specifications drive everything. You own the spec and the architecture for the features you deliver, coding agents build from them, and you review every line that comes back, judge whether the tests prove the spec, and ship to Azure. We use GitHub Spec Kit and Claude Code today, and the practice is still evolving as the tools do. You are responsible for whether the result is correct, secure, maintainable, and what the client needed, regardless of which agent wrote it. *The role* You will deliver a mix of three kinds of work, all spec driven and agent built.

• *Application and UI work.* Line-of-business and customer-facing web applications where the front end matters: component architecture, state management, accessibility, responsive layouts, and the design patterns that make an Angular, React, or Blazor application maintainable at scale. You specify these patterns and hold the agent to them.
• *Agents and MCP servers.* Agentic workflows, AI capabilities, and the MCP servers that expose client systems and data to them, built with Azure OpenAI, Microsoft AI Foundry, Semantic Kernel, and Microsoft Agent Framework: retrieval over client data, tool calling, structured outputs, multi-step agents, evaluation, and the human-in-the-loop controls that make them safe to ship.
• *Data and AI platform projects.* Heavy data and AI engagements on Microsoft Fabric (lakehouse, pipelines, notebooks, semantic models), Microsoft Purview (governance, lineage, classification), and AI Foundry, where the application is one part of a larger platform and the spec has to cover data architecture, governance, and integration, not just screens and APIs. Most of our code is still C# and TypeScript; Python shows up increasingly on the data analytics side of these projects, which run on Fabric or Databricks depending on the client.

As an Agentic Software Engineer you sit on a delivery pod with a Tech Lead, a Delivery Lead, and two or three other developers, delivering .NET and Angular, React, or Blazor applications on Azure. The shape of the work varies. Some engagements are long-term partnerships with a single client where you know the system and the stakeholders well; at other times you will balance a few simultaneous deliverables across clients, along with support and enhancement requests on applications we have already shipped. Managing that mix within a week, and being clear with your Delivery Lead about what is on your plate, is part of the role. Your value is not typing speed. It is the quality of your specs and architecture, the sharpness of your review, and your judgment about when the agent is right, when it is wrong, and when to throw its output away. *What you will actually do* *A typical week.* Most weeks touch more than one client and more than one kind of work. Monday in sprint planning you walk the pod through the spec you wrote for a new intake workflow, and the Tech Lead flags a data-model question you resolve before it is approved. Tuesday you kick off two Claude Code sessions: one building the ASP.NET Core API and its integration tests, one building the Angular screens against the contract. You review each diff as it lands, and in the afternoon you pick up a support ticket from a client whose application went live last quarter, have an agent reproduce and fix it, verify the fix, and ship it. Wednesday you have an agent wire the Azure OpenAI call and generate the evaluation set from the acceptance criteria, then you rewrite half the eval cases because the agent's were too easy. Thursday you review a teammate's agent-generated PR, catch a missed authorization check the spec called for, demo the shipped feature to the client's product owner, and join a requirements session for a second client's Fabric project that starts next sprint. Friday you turn the pattern that worked on Tuesday into a Claude skill in our internal library. *Specifically, you will*

• Write and own the specifications and architecture for the features you deliver
• Direct coding agents (Claude Code on our team) and our internal agents, skills, and MCP servers to implement those specifications, and review every line they produce
• Build and maintain full-stack web applications with C# and current .NET, ASP.NET Core APIs, and Angular or React with TypeScript, or Blazor
• Specify and hold agents to the UI architecture and design patterns of Angular, React, or Blazor applications: component structure, state management, accessibility, and responsive design
• Build agents, MCP servers, and AI features for client systems: Azure OpenAI, Microsoft AI Foundry, Semantic Kernel, and Microsoft Agent Framework, with MCP servers exposing client data and tools, retrieval over client data, structured outputs, tool calling, multi-step agents, evaluation sets, and human review where it matters
• Contribute to data and AI platform engagements on Microsoft Fabric and Purview, specifying data architecture, governance, and integration alongside the application work
• Use agents to generate and maintain automated tests from acceptance criteria, and judge whether that coverage actually proves the spec
• Build and run on Azure, including App Service, Functions, Azure SQL, Cosmos DB, storage, and Entra ID, with agents producing the infrastructure and pipeline changes you review. Our source control and pipelines are primarily GitHub, with Azure DevOps on some client backlogs
• Keep CI/CD in GitHub Actions or Azure DevOps healthy and use agents to draft PR descriptions, release notes, and deployment checklists you verify
• Balance work across engagements: a long-term client relationship, a few simultaneous deliverables, and support and enhancement requests on applications already in production, keeping your Delivery Lead informed of capacity and priorities
• Take part in sprint ceremonies, estimates, code reviews, and design discussions
• Work directly with client stakeholders throughout delivery: requirements sessions, demos, working sessions, and the day-to-day communication that keeps a client confident in the work
• Contribute to our internal library of spec templates, Claude skills, MCP servers, and agents, and help evolve the delivery process as the tooling matures

*Who we are looking for* This role writes little code directly, but it is not a hands-off role. You will spec, direct, review, test, and ship software every week, and the quality of what ships is yours. We care less about years with a particular framework and more about whether you have shipped production software through a spec driven, agentic workflow and can show us how. The specific agent matters less than the practice: Claude Code, OpenAI Codex, GitHub Copilot coding agent, Cursor, or another agentic tool all count, provided you have used it to build real software from specifications, not just for autocomplete. The developers who do well here write specs and architecture an agent can actually execute, read generated code critically, test it properly, and know when to intervene. They also treat the process itself as something to improve: they notice where a spec template falls short, build the skill or MCP server the team is missing, and bring new tools to the group when they prove out. And two traits matter as much as any of the above. First, communication and collaboration. In this role your specifications are the product, your pod depends on them, and your clients read them. You will spend much of your week working closely with client stakeholders and with your Tech Lead, Delivery Lead, and fellow developers, and you need to write clearly, listen well, and keep everyone aligned. Second, ownership. We are looking for someone who takes real ownership and follows through on what they commit to. Our clients stay with us through hard projects because the people on our teams are people they want to work with. Both are non-negotiable. *Required*

• Hands-on production experience with spec driven, agentic development: writing specifications that a coding agent implements, and delivering real features that way. GitHub Spec Kit experience is ideal; a comparable spec driven approach counts. You can show us a real example
• An agentic coding tool as your primary daily development tool. Claude Code, OpenAI Codex, GitHub Copilot coding agent or CLI, Cursor agent mode, or comparable, used to run work end to end rather than for inline suggestions. You can explain how you direct it, how you check its output, and where you have learned not to trust it. Our team works in Claude Code, so direct experience with it is a plus but not a requirement
• 4+ years of professional software development building and shipping production web applications. This is a hard requirement regardless of agentic experience
• Strong C# and .NET, including ASP.NET Core and designing and consuming REST APIs
• Proficiency with Angular or React with TypeScript, or Blazor, including the architecture and design patterns of a large front end
• Solid SQL and relational data modeling
• Experience designing, deploying, and running cloud-native applications on Azure, or another major cloud with a willingness to go deep on Azure
• Agent-assisted automated testing as a normal part of how you build, and the judgment to tell adequate coverage from theater
• Git, pull requests, and critical code review of agent-generated diffs as everyday practice
• Experience on an agile team working in sprints
• Consulting, agency, or equivalent client-facing experience: working directly with client stakeholders to shape requirements, run working sessions, present and demo your work, and handle the conversations when priorities or scope change
• Clear, structured written communication. Your specifications, plans, and review notes are read by agents, teammates, and clients, and the quality of that writing is the quality of the work
• Strong collaboration habits on a delivery team: pairing with a Tech Lead on architecture, keeping a Delivery Lead informed, reviewing teammates' work constructively, and asking for help early
• Ownership and follow-through. Non-negotiable

*Bonus*

• *Microsoft Fabric or Databricks, and Python.* A real plus. Hands-on Fabric or Databricks experience (lakehouse, pipelines, notebooks, semantic models) on a real engagement, and working Python for the data analytics side of those projects. Our core stack remains C# and TypeScript, but Fabric, Databricks, and Python are growing in our data work
• AI features, agents, or MCP servers you have built for a production application using Azure OpenAI, Microsoft AI Foundry, Semantic Kernel, Microsoft Agent Framework, or comparable, including retrieval, tool calling, or evaluation
• Microsoft Purview (governance, lineage, classification) on a real engagement
• Direct Claude Code experience, especially multi-session or parallel agent work, custom skills, subagents, hooks, or MCP servers
• A Claude skill, MCP server, subagent, or agent hook you have built and others use
• Experience across more than one agentic tool (for example Claude Code plus Codex, Copilot coding agent, or Cursor)
• GitHub Actions or Azure DevOps CI/CD, and infrastructure as code (Bicep or Terraform)
• Cosmos DB or other NoSQL databases
• Power Platform, Dataverse, or Dynamics 365
• Mobile development with React Native or .NET MAUI
• Microsoft certifications such as AZ-204, AI-102, or DP-600
• A blog, repo, or write-up that shows your spec driven workflow in practice

*The AI stack you will have* We treat agentic development as the way we build, not an experiment, and we fund it accordingly. Every member of the development team has

• A Claude Team Premium plan with a large token budget. Running multiple Claude Code sessions in parallel all day is the expected way of working, not something to ration
• GitHub Spec Kit integrated into every project
• GitHub Copilot, and Microsoft Copilot across the M365 suite
• Our internal library of spec templates, Claude skills, MCP servers, and agents, and a real opportunity to extend them
• Time and budget to try new tooling as the field moves

*Our hiring process* This is a US-based remote, direct-hire position. Candidates must be authorized to work in the United States without current or future sponsorship, and we do not work with third-party recruiters, staffing firms, or corp-to-corp arrangements.

• *Resume review.* We review every submission against the requirements of the role.
• *Pre-interview screening exam.* A real-world use case completed in CoderPad using spec driven development, with roughly one to two hours of commitment.
• *Identity verification.* A brief online check to confirm your identity, completed after the screening exam.
• *Virtual interviews.* Several rounds with members of our delivery team and management.
• *Background check.* A full federal and all-50-state background check is required after offer acceptance and before hire.

*How to apply* Submit your resume with a short note describing one feature you delivered end to end using a spec driven, agentic workflow: which tools you used, what the spec covered, what the agent got wrong, and what you changed. Applications that do not address this will not be reviewed. *Compensation and benefits* Base salary $120,000 to $150,000, depending on experience.

Application Question(s):

• Describe one feature you delivered end to end using a spec-driven, agentic workflow (for example GitHub Spec Kit with Claude Code, OpenAI Codex, GitHub Copilot coding agent, or Cursor). Which tools did you use, what did the specification cover, what did the agent get wrong, and what did you change before it shipped?