Role Definition
| Field | Value |
|---|---|
| Job Title | Computer Programmer |
| Seniority Level | Mid-Level (3-7 years) |
| Primary Function | Writes, tests, and maintains code from specifications created by software developers and systems analysts. Translates program designs into working code, debugs existing programs, conducts trial runs, writes documentation, and revises programs for efficiency or new requirements. Works from detailed specifications — does not design systems. |
| What This Role Is NOT | Not a Software Developer (SOC 15-1252, who designs systems and makes architectural decisions). Not a junior developer (has 3-7 years of independent coding experience). Not a systems programmer (doesn't work on OS, kernels, or compilers). BLS explicitly distinguishes this from developers — programmers implement, developers design. |
| Typical Experience | 3-7 years. Bachelor's in computer science typical. Proficient in multiple languages. No certification required. |
Seniority note: A junior computer programmer (0-2 years) would score deeper Red (~8-9). The role title itself is declining at all seniority levels — BLS is actively consolidating SOC 15-1251 into Software Developers (15-1252). Senior programmers who've evolved into design work are already functionally "developers."
Protective Principles + AI Growth Correlation
| Principle | Score (0-3) | Rationale |
|---|---|---|
| Embodied Physicality | 0 | Fully digital, desk-based. All work happens in IDEs and terminals. |
| Deep Interpersonal Connection | 0 | Works primarily from written specifications. Collaboration is transactional — clarifying requirements, not building trust-based relationships. |
| Goal-Setting & Moral Judgment | 0 | Follows specifications written by developers and analysts. Implements what's defined, does not set direction or make design decisions. |
| Protective Total | 0/9 | |
| AI Growth Correlation | -2 | AI directly replaces spec-to-code translation — the defining task. BLS projects -6% decline. Role is being absorbed into Software Developer as AI handles the coding step. More AI = less need for dedicated programmers. |
Quick screen result: Protective 0/9 AND Correlation -2 — almost certainly Red Zone.
Task Decomposition (Agentic AI Scoring)
| Task | Time % | Score (1-5) | Weighted | Aug/Disp | Rationale |
|---|---|---|---|---|---|
| Writing/coding programs from specifications | 25% | 5 | 1.25 | DISPLACEMENT | AI coding tools generate code from specifications end-to-end. GitHub Copilot, Cursor, Claude Code produce working implementations from detailed specs — the literal job description. |
| Testing, debugging, and correcting errors | 20% | 4 | 0.80 | DISPLACEMENT | AI agents diagnose bugs from stack traces, generate test suites, and produce fixes. Well-documented error correction is agent-executable with human review. |
| Maintaining and revising existing programs | 15% | 4 | 0.60 | DISPLACEMENT | Code refactoring and updates from defined requirements are highly automatable. AI handles routine maintenance with human review for complex legacy interactions. |
| Writing documentation | 5% | 5 | 0.25 | DISPLACEMENT | AI generates technical documentation from code at production quality. Deterministic, verifiable output. |
| Conferring with analysts/developers on requirements | 15% | 2 | 0.30 | AUGMENTATION | Human communication to clarify specifications, negotiate requirements, and assess constraints. AI assists preparation but the interpersonal coordination remains human. |
| Analyzing requirements and feasibility | 10% | 3 | 0.30 | AUGMENTATION | AI assists analysis but human judgment on feasibility within time, cost, and system constraints. Mid-level experience provides contextual knowledge AI lacks. |
| Conducting trial runs and quality validation | 10% | 3 | 0.30 | AUGMENTATION | AI generates and runs tests but human validates business correctness and edge cases requiring domain understanding. |
| Total | 100% | 3.80 |
Task Resistance Score: 6.00 - 3.80 = 2.20/5.0
Displacement/Augmentation split: 65% displacement, 35% augmentation, 0% not involved.
Reinstatement check (Acemoglu): Minimal. "Validate AI-generated code" is emerging but leans toward software developers who understand system design. The computer programmer role is shrinking, not transforming — the work that remains is being absorbed into the developer role. No significant new tasks are being created for the programmer-as-implementer.
Evidence Score
| Dimension | Score (-2 to 2) | Evidence |
|---|---|---|
| Job Posting Trends | -2 | BLS projects -6% decline (2024-2034) for SOC 15-1251 — one of the few tech roles with negative growth. Only 121,200 jobs remain (vs 1.7M software developers). "Computer programmer" postings declining as companies retitle to "software developer." Only ~5,500 annual openings, driven by retirements rather than growth. |
| Company Actions | -1 | Companies consolidating "programmer" roles into "developer" titles rather than hiring dedicated programmers. BLS is itself merging the occupation — the role distinction is dissolving. Not as dramatic as junior dev layoffs (no Stanford DEL-style data), but steady attrition without replacement. |
| Wage Trends | -1 | Median $98,670 — significantly below Software Developer median of $133,080. The $35K gap reflects market valuation: implementation is worth less than design. Wages stagnating while AI/ML specialists command 20-40% premiums. |
| AI Tool Maturity | -2 | Production tools directly automate spec-to-code: GitHub Copilot (76M+ developers), Cursor, Claude Code, Devin. These tools perform the core computer programmer task — translating specifications into working code. SWE-bench agents solve 40%+ of real GitHub issues autonomously. |
| Expert Consensus | -2 | BLS itself projects decline — the strongest possible institutional signal. AI leaders agree spec-to-code is the most automatable programming task. The role title is becoming an anachronism as the BLS consolidates it into Software Developers. |
| Total | -8 |
Barrier Assessment
Reframed question: What prevents AI execution even when programmatically possible?
| Barrier | Score (0-2) | Rationale |
|---|---|---|
| Regulatory/Licensing | 0 | No licensing required. No regulatory body governs who can write code. |
| Physical Presence | 0 | Fully remote-capable. All work happens through terminals and IDEs. |
| Union/Collective Bargaining | 0 | Software workers overwhelmingly non-unionised, at-will employment. |
| Liability/Accountability | 0 | Programmers have no personal liability. Code is reviewed by developers, tested through QA, deployed through CI/CD. No legal barrier to AI-generated code. |
| Cultural/Ethical | 0 | Zero cultural resistance. Tech industry enthusiastically adopts AI coding tools. 84% of developers already use AI assistants. |
| Total | 0/10 |
AI Growth Correlation Check
Confirmed at -2 (Strong Negative). BLS projects -6% decline — AI adoption directly reduces demand for dedicated programmers. Each developer with Copilot/Cursor handles the coding work that previously required separate programmers. The role's defining task (spec-to-code) is the canonical AI capability. Unlike Software Developers (who grow as AI creates more software), Computer Programmers shrink because AI replaces the translation layer they provide. The occupation is being absorbed into Software Developer, not transformed.
JobZone Composite Score (AIJRI)
| Input | Value |
|---|---|
| Task Resistance Score | 2.20/5.0 |
| Evidence Modifier | 1.0 + (-8 × 0.04) = 0.68 |
| Barrier Modifier | 1.0 + (0 × 0.02) = 1.00 |
| Growth Modifier | 1.0 + (-2 × 0.05) = 0.90 |
Raw: 2.20 × 0.68 × 1.00 × 0.90 = 1.3464
JobZone Score: (1.3464 - 0.54) / 7.93 × 100 = 10.2/100
Zone: RED (Green ≥48, Yellow 25-47, Red <25)
Sub-Label Determination
| Metric | Value |
|---|---|
| % of task time scoring 3+ | 85% |
| AI Growth Correlation | -2 |
| Sub-label | Red — Task Resistance 2.20 ≥ 1.8, does not meet all three Imminent conditions |
Assessor override: None — formula score accepted.
Assessor Commentary
Score vs Reality Check
The Red label is unambiguous. BLS projects actual employment decline — an institutional signal that carries more weight than any task analysis. The 0/10 barrier score means there is nothing between AI capability and actual displacement. The 10.2 score lands between Junior Software Developer (9.3) and Frontend Developer (13.5), which is directionally correct: a mid-level programmer's experience provides marginal protection through requirements analysis and domain knowledge, but the core task (spec-to-code) is identical to the junior dev's most automated work.
What the Numbers Don't Capture
- Title rotation masking the decline. "Computer Programmer" is being absorbed into "Software Developer" — the people may continue working but the role disappears. BLS tracking shows a declining occupation, but some of that decline is reclassification rather than unemployment. The framework scores the role, not the person's employability under a new title.
- BLS consolidation as meta-signal. When BLS itself merges an occupation into a broader category, it's not just a statistical adjustment — it reflects genuine market reality that the role distinction has lost meaning. This is a structural signal the framework can score but understates.
- Legacy system moat is temporary. Mid-level programmers maintaining undocumented COBOL/Fortran systems have short-term protection. But AI context windows and code understanding are expanding rapidly — the legacy moat erodes within 2-4 years.
Who Should Worry (and Who Shouldn't)
If your daily work is translating detailed specifications into code, writing tests from defined requirements, and maintaining programs others designed — you are doing the exact work AI coding tools perform at production quality. The "computer programmer" title IS the automation target. 12-24 month window.
If you've evolved into making design decisions, leading technical discussions, and collaborating on system architecture — you're functionally a software developer, not a programmer in the BLS sense. Your actual work is safer than the label suggests. The question is whether your title and compensation reflect the work you actually do.
The single biggest separator: whether you implement specifications or contribute to creating them. A programmer who takes specs and produces code is being displaced. A programmer who participates in requirements analysis, proposes design alternatives, and makes architectural trade-offs is operating as a developer — and should retitle accordingly.
What This Means
The role in 2028: The "Computer Programmer" as a distinct occupation effectively ceases to exist. BLS is already consolidating it into Software Developer. The spec-to-code translation that defined this role is handled by AI coding tools. Surviving programmers have either transitioned into developer roles (with design responsibility) or into specialised niches maintaining critical legacy systems.
Survival strategy:
- Transition from programmer to developer. The distinction matters: developers design, programmers implement. Start making design decisions, proposing architectural approaches, and contributing to system design — this is the work that resists automation.
- Master AI coding tools as force multipliers. Copilot, Cursor, and Claude Code can make a programmer produce developer-level output. Use them to leapfrog from implementation to design.
- Specialise in domains AI struggles with. Legacy system modernisation, real-time systems, embedded programming, and security-critical code all require domain expertise that provides a moat.
Where to look next. If you're considering a career shift, these Green Zone roles share transferable skills with this role:
- Senior Software Engineer (AIJRI 55.4) — Direct career progression — deepen into system design, architecture, and technical leadership
- Systems Software Developer (AIJRI 51.7) — Low-level programming expertise transfers to kernel, compiler, and driver work where AI struggles
- DevSecOps Engineer (AIJRI 58.2) — Programming skills and code review experience map to security pipeline automation
Browse all scored roles at jobzonerisk.com to find the right fit for your skills and interests.
Timeline: 12-36 months. BLS projects -6% decline. Zero barriers to slow adoption. The tech industry is enthusiastically automating the spec-to-code workflow that defines this role.
