A senior engineer can be a strong hire without years of experience in your languages, frameworks, or databases. The question is whether they can acquire the knowledge the work requires, identify technical risks, and establish that their changes behave correctly.
Agentic engineering gives that distinction practical importance. Coding agents can help engineers investigate unfamiliar systems and implement changes, while the engineer remains responsible for the requirements, technical decisions, and evidence of correctness. [1] [2]
For a hiring manager, I would therefore treat prior stack experience as one source of evidence, rather than an automatic requirement for every senior role. The decision also depends on the work's risks and the safeguards the team has in place.
The engineer must understand the system well enough to take responsibility for it. They do not always need to arrive with that stack knowledge already acquired.
How do you assess a senior engineer in an unfamiliar stack?
Give the candidate a small, bounded problem in a technology they have not used deeply. Let them consult documentation and use a coding agent. Agree on the expected outcome, then examine what they clarify, investigate, verify, and escalate before accepting the result.
The payment-and-refund example later in this article can serve as an exercise: return a customer's net paid amount without counting a payment twice when it has multiple refunds.
| Capability | Interview exercise | Evidence of competence |
|---|---|---|
| Requirements analysis | Ask what should count toward a customer's net paid amount. | Clarifies payment and refund statuses, currency units, and customer boundaries before implementation. |
| Research | Ask how the unfamiliar database supports the required guarantees. | Checks the relevant documentation and identifies assumptions that need an experiment or specialist review. |
| Implementation review | Ask the candidate to explain a generated change and investigate one assumption. | Connects the code to the contract, checks its assumptions, and identifies where specialist review is needed. |
| Independent verification | Provide one payment with two refunds and ask how to establish the expected result. | Defines the expected amount from the business rule, then checks the implementation against it. |
| Operational judgment | Ask how to investigate a slow or incorrect production response. | Chooses useful telemetry, representative checks, and a safe way to contain the failure. |
| Recognizing limits | Introduce a destructive migration or a difficult concurrency requirement. | Identifies evidence that is still missing and explains when additional expertise is necessary. |
A passing test is one piece of evidence. The stronger signal is whether the candidate can explain why the chosen checks are sufficient for this change and which risks remain unresolved. For the SQL example, also ask about no refunds, pending payments, and records belonging to another customer.
The changing value of technology-specific expertise
Historically, implementation knowledge was a significant bottleneck in software development.
An engineer working with PostgreSQL needed to understand SQL, the database's behavior, and the relevant ecosystem well enough to implement and troubleshoot their solutions. Someone working with Java needed to know the language, its runtime, its frameworks, and their conventions.
Even an engineer who understood the underlying problem perfectly could be slowed down considerably by an unfamiliar implementation technology.
Agentic coding is changing that relationship.
Modern coding agents can explore unfamiliar repositories, consult documentation, implement changes, run tests, investigate errors, and iteratively improve their solutions. Engineers can increasingly work effectively with technologies in which they have little prior experience.
Michael Werle describes this shift in Become Builders, Not Coders, explaining how agentic tools have enabled him to produce code in languages he can barely read. He also reports having known experts review the results. [1]
The important implication is not that implementation details have stopped mattering. Rather, implementation knowledge has become much more accessible on demand.
What remains difficult is deciding what to implement in the first place, recognizing incomplete requirements, making architectural trade-offs, identifying risks, and establishing confidence that a solution works under real-world conditions.
Martin Fowler makes a related distinction in Agentic Engineering: engineers remain responsible for what their software does and how it works, even when agents produce the implementation. His description includes human code review, examination of test results, and other evidence from the system. [2]
This changes what we should expect from an excellent engineer.
The skill set of a stack-agnostic engineer
The engineer I'm describing is not simply a generalist who knows a little about everything.
A useful way to think about this role is as a different kind of T-shaped engineer: someone with broad technical literacy and substantial depth in transferable engineering disciplines rather than necessarily in one particular programming language or framework.
These disciplines become especially important when agents can perform much of the implementation work.
Understanding problems before designing solutions
One of the most important engineering skills is the ability to understand what a product actually needs to accomplish.
Requirements frequently describe a proposed solution rather than the underlying problem.
A request to add a background job, for example, may really express a requirement for reliable asynchronous processing. That raises questions about latency, retries, duplicate execution, ordering, recoverability, and what should happen when the dependent service is unavailable.
A good engineer doesn't immediately accept the proposed implementation. They work backward to understand the desired outcome and the assumptions behind it.
This involves challenging requirements, identifying ambiguous terminology, uncovering edge cases, and distinguishing essential behavior from incidental implementation details.
The result should be a sufficiently precise description of what must be true for the feature to be considered correct.
AI can help with this discovery process, but it cannot reliably determine which unstated business assumptions are true. Those must be established through reasoning, research, and collaboration with the people who understand the domain.
The engineer's job is to discover and define the problem well enough that implementation becomes a verifiable task.
Systems thinking instead of framework thinking
A senior engineer needs to understand how the pieces of a system interact.
That includes data flows, service boundaries, consistency requirements, failure propagation, concurrency, security, resource consumption, and the consequences of architectural decisions.
These concerns are largely independent of the technologies used to implement them.
The same conceptual questions arise whether a service is written in Go, Java, TypeScript, or another language.
What happens when two requests modify the same resource concurrently? What happens if a message is delivered twice? What if a service becomes unavailable halfway through a workflow? Which operations must be atomic? What guarantees does the system make about persisted data?
The answers may require technology-specific implementation knowledge, but the questions themselves do not.
An engineer who understands these principles can investigate how an unfamiliar stack implements the necessary guarantees.
Conversely, an engineer who knows a framework exceptionally well but fails to recognize the underlying system-level risks can still produce unreliable software.
The fundamental skill is recognizing what matters at the system level, not remembering how a particular framework implements it.
Researching unfamiliar technologies and uncovering unknown unknowns
An engineer working with unfamiliar technology must be an exceptionally capable researcher.
It isn't enough to ask an AI model how to implement something and accept the result.
The engineer must systematically discover what they don't yet know.
Before introducing an unfamiliar database, for example, they might investigate its transaction guarantees, isolation levels, indexing behavior, migration mechanisms, operational limitations, backup strategies, and relevant performance characteristics.
AI is particularly useful for generating an initial map of the problem space.
Instead of only asking how to implement a feature, the engineer can ask what might go wrong, which assumptions should be verified, what requirements are commonly overlooked, and what changes when the workload becomes substantially larger.
The resulting findings should be checked against authoritative documentation, the actual versions in use, experiments, and observable behavior.
This is an important difference between researching until an answer sounds convincing and researching until there is sufficient evidence to make a decision.
A capable engineer also needs to know when uncertainty cannot reasonably be resolved through individual research and when specialist involvement is justified.
Prior knowledge of a technology becomes less important when an engineer is capable of acquiring the required knowledge reliably, efficiently, and at the point where it is needed.
Designing architectures around explicit trade-offs
Architecture is not about knowing the preferred design pattern of a particular framework.
It is about making decisions under constraints.
A good engineer must understand the trade-offs between simplicity, maintainability, performance, scalability, consistency, availability, security, and development cost.
They should avoid unnecessary abstraction, keep changes localized, establish clear boundaries, and design systems that are easy to investigate and modify.
These qualities become even more important with AI-generated implementations.
As discussed in How to Design a Maintainable Codebase for AI Coding Agents, a codebase should allow an unfamiliar agent to find relevant context, make a bounded change, and verify its effects without needing to understand the entire system.
That principle is equally useful for human engineers approaching an unfamiliar stack.
An architecture that makes change safe and understandable reduces the amount of technology-specific knowledge required for each individual modification.
Translating intent into executable constraints
Working effectively with coding agents requires more than writing good prompts.
The engineer needs to translate requirements into explicit specifications, acceptance criteria, architectural constraints, and verification procedures.
Agents should have access to the relevant product semantics, codebase conventions, system boundaries, and operational requirements.
Large changes should be decomposed into independently verifiable steps. Implementation discoveries should be reconciled with the original requirements, rather than silently becoming new assumptions.
This is one reason I consider docs-first product development important for agentic engineering.
Documentation isn't merely explanatory material for developers. It can serve as a durable contract that defines product meaning and constrains implementation.
However, an agent completing its assigned task is not sufficient evidence of correctness.
A model reviewing another model's output can be useful, but both may share the same mistaken assumptions. Independent checks, executable constraints, and actual system behavior are considerably stronger evidence.
The engineer must therefore know how to establish verification mechanisms that don't depend exclusively on an AI model judging its own work.
The practical mechanisms are covered in docs, guardrails, and feedback loops for AI coding agents: explicit behavior, enforced boundaries, and focused checks that can reject an incorrect implementation.
Reviewing the implementation before accepting it
The acceptance decision should combine source-code review, independent checks, and operational evidence. The engineer needs to understand the change's data flow, assumptions, dependencies, and failure modes well enough to challenge its implementation.
That understanding can be acquired during the work: read the relevant code, consult documentation, trace execution, and investigate uncertain behavior. An agent's explanation can guide the investigation, but its claims need to be checked against the source, documentation, and observed behavior.
Where the review depends on expertise the engineer cannot establish within the available time and risk budget, involve a suitable specialist before accepting the change. Stack knowledge can be learned during delivery; understanding the implementation remains part of taking responsibility for it.
Evidence-driven engineering and operational judgment
Perhaps the most consequential skill is the ability to establish whether a system actually works.
Rather than relying primarily on personal confidence in an implementation, engineers should seek measurable evidence.
Does the software fulfill its functional requirements? Are important business invariants preserved? Does it behave correctly under concurrent requests? Can it recover from failures? Does it meet the required performance and scalability targets?
When a problem occurs, can the engineer identify its cause and verify that the proposed correction resolves it without introducing regressions?
These questions matter more than whether the engineer could have written the implementation manually.
A senior engineer should be skilled at building the feedback loops that make those questions answerable.
But these skills only provide the intended advantages when the software stack itself supports them.
What safeguards make agentic engineering reliable?
Reliable agentic engineering requires independently specified behavior, automated checks, observable production behavior, safe recovery, and enforceable controls for high-risk operations. Those safeguards let an engineer investigate an unfamiliar implementation while keeping its effects verifiable and containable.
Stack-agnostic engineering cannot depend on the assumption that AI-generated code will always be correct.
It needs an environment in which implementation mistakes can be prevented where necessary, detected reliably, investigated efficiently, and corrected safely.
The objective is to reduce dependence on any individual's ability to recognize every potential implementation flaw by inspection.
These requirements apply regardless of the programming languages, frameworks, or databases used.
Correctness must be testable from the outside
The most important safeguard is automated verification of explicit behavioral contracts.
The default should be the smallest test that can establish the required behavior. Unit tests check local rules; integration tests check interactions such as database queries; API tests check externally visible contracts. A focused set of end-to-end tests covers critical user journeys across those boundaries.
"From the outside" refers to the boundary being tested. A calculation can be verified through its public interface without running the entire application.
Where correctness depends on database semantics, run the relevant checks against the real database engine, with deterministic fixtures and controlled environments. Use property-based tests, concurrency tests, and other targeted checks where the risks justify them.
For agentic engineering, this keeps feedback fast and failures easier to locate. An agent can change an implementation while the tests continue to enforce its behavioral contract. Google's discussion of end-to-end testing explains why a testing strategy should help engineers diagnose and fix failures efficiently. [3]
A passing suite establishes behavior for the cases it exercises. The engineer still needs to identify relevant risks, including concurrency and failure modes, and decide which additional evidence is needed.
For agentic development, the central principle is that the expected behavior should be specified independently of the implementation whenever possible.
Otherwise, an AI agent can produce both an incorrect implementation and tests that merely confirm its incorrect assumptions.
The system must expose its internal behavior in production
Tests can reduce the likelihood of production failures, but they cannot eliminate them.
Production systems encounter unexpected workloads, unusual data, infrastructure problems, external dependencies, and combinations of events that are difficult to reproduce beforehand.
This makes comprehensive observability essential.
Applications should emit structured logs, metrics, distributed traces, and error events. Those signals should be correlated so an engineer can follow an operation across frontend interactions, API requests, background jobs, database operations, and external services.
Error tracking systems such as Sentry should capture exceptions, relevant stack traces, release information, and useful execution context.
Distributed tracing should make it possible to identify which operation consumed time or failed, even when a request crosses multiple services.
OpenTelemetry describes observability as the ability to understand a system from the outside and investigate unexpected behavior without already knowing its inner workings. [4]
That property is particularly valuable to stack-agnostic engineers.
When a production request fails, they should be able to establish what happened before needing to become experts in the underlying framework.
Relevant diagnostic information should be retained long enough to investigate delayed reports and regressions. Logs and traces should be associated with deployment versions, relevant feature-flag states, and correlation identifiers.
This does not mean indiscriminately storing every request payload or every piece of user data. Sensitive information must be protected, and retention, access controls, and sampling must be designed deliberately.
The objective is to preserve enough relevant evidence to reconstruct and understand failures without creating unnecessary privacy or security risks.
Correctness must be monitored beyond exceptions
A system can produce incorrect results without throwing an exception.
An order can be processed twice. A financial calculation can produce the wrong total. A background task can silently stop processing a subset of its input.
Ordinary error tracking may report nothing unusual.
Consequently, mature systems should enforce important business invariants and monitor domain-level correctness.
Database constraints can prevent invalid states. Reconciliation processes can identify inconsistencies. Business-level monitoring can detect missing events, duplicate operations, unexpected state transitions, or incorrect aggregate results.
The relevant safeguards depend on the domain and the consequences of failure.
Google's Site Reliability Engineering guidance on SLOs explicitly recognizes correctness, freshness, and durability as meaningful reliability dimensions, not just availability and response time. [5]
This matters because external behavioral validation is only useful when the engineer has correctly identified what behavior must be guaranteed.
It is another reason why requirements analysis and systems thinking remain fundamental.
Deployments must be reversible and failures containable
A reliable engineering process must assume that some changes will fail in production.
The system should make those failures relatively inexpensive to mitigate.
Deployment pipelines should retain identifiable, previously deployed artifacts and make it straightforward to restore a known-good application version.
Deployment histories, associated configuration, and relevant diagnostic information should remain accessible after a rollback.
Progressive rollouts and canary deployments can expose changes to a limited audience before they become widely available.
Feature flags should allow risky or optional functionality to be disabled without requiring another application deployment. Important operational kill switches should have well-defined and tested fallback behavior.
These mechanisms give engineers time to investigate difficult problems without leaving users exposed to an ongoing failure.
The coding-agent workflow needs recovery guarantees too when it runs for long periods or changes external systems. As discussed in durable execution for long-running coding agents, resuming a failed workflow requires persisted progress, recoverable workspaces, and protection against repeating an external effect.
However, rollback is not universally equivalent to undoing a change.
Database migrations, external API calls, payments, and other persistent side effects may not be reversible simply by redeploying older code.
Database changes should therefore be designed for backward compatibility where practical. AWS's blue/green deployment guidance discusses why decoupling database schema changes from application deployments is important for rollback safety. [6]
Systems that handle important data should also have tested backup and recovery procedures, and operations with irreversible consequences should have appropriate preventive controls.
The ability to stop a failure safely is often more important than the ability to understand and repair its implementation immediately.
Performance and scalability must be measurable
Software does not need to be maximally optimized. It needs to satisfy its performance, reliability, and cost requirements.
This distinction has existed for decades, long before AI-generated code.
Carlos Bueno's The Mature Optimization Handbook makes the case for treating optimization as an economic decision rather than an automatic goal. [7]
AI-generated implementations should be evaluated against the same principle.
A query that already meets its latency and resource-consumption targets does not necessarily require further optimization merely because a database expert could write a faster version.
At the same time, avoiding premature optimization does not justify ignoring foreseeable scalability problems.
Systems should define appropriate performance budgets, expected workload characteristics, and operational limits. Relevant components should be tested with representative data volumes, concurrency, and traffic patterns before they encounter those conditions in production.
Performance monitoring should identify latency regressions, excessive resource use, and unexpected infrastructure costs.
This allows engineering effort to be directed toward demonstrated bottlenecks and credible future constraints rather than speculative micro-optimizations.
The engineer's responsibility is to establish that the system can handle its expected workload, not to optimize every implementation detail preemptively.
The development environment must make investigation reproducible
A production incident is significantly easier to fix when the software can be reproduced in a controlled environment.
Dependencies and runtime versions should be identifiable. Infrastructure and configuration should be reproducible where practical. Test environments should support realistic fixtures, and CI pipelines should execute the relevant verification procedures consistently.
Operational runbooks should explain how to investigate common failure categories, reproduce problems, inspect telemetry, and perform safe recovery actions.
These capabilities are useful for every engineer. But they are particularly valuable when someone needs to investigate a technology they do not yet understand deeply.
An AI agent can explore source code, inspect documentation, reproduce a failing test, run a diagnostic command, and evaluate a candidate fix far more effectively when the environment provides these capabilities consistently.
High-risk operations need enforceable safeguards
Not every failure can be safely fixed after it happens.
Accidental data deletion, privilege escalation, disclosure of sensitive information, and certain externally visible side effects can have consequences that no rollback fully reverses.
For these categories, detection and recovery must be complemented by prevention.
Authentication and authorization boundaries, least-privilege access, database constraints, secure defaults, isolated execution environments, protected secrets, and appropriately restricted agent permissions should be enforced by the system.
High-impact operations may require explicit approval or additional verification.
These controls should not depend solely on an AI model remembering an instruction.
The more implementation work is delegated to agents, the more important it becomes to encode non-negotiable requirements as enforceable constraints rather than advisory documentation.
Why deep stack expertise is not always required
SQL is a useful example because it exposes many of the strongest objections to stack-agnostic engineering.
Database-backed systems can contain subtle correctness problems, inefficient queries, concurrency anomalies, and scalability issues. Some of these problems are difficult to identify simply by reading the code.
Traditionally, this has supported the argument that senior backend engineers must be deeply proficient in SQL.
But consider what an engineer actually needs to accomplish.
Suppose an API endpoint returns a customer's net paid amount. For this example, all amounts are in EUR cents. The contract counts each settled payment once and subtracts each completed refund against those payments once. Pending payments contribute nothing.
Consider this fixture for one customer:
| Record | Status | Amount (cents) |
|---|---|---|
| Payment A | Settled | 10000 |
| Refund A for Payment A | Completed | 1000 |
| Refund B for Payment A | Completed | 2000 |
| Payment B | Pending | 5000 |
The expected response is net_paid_cents: 7000: 10000 - 1000 - 2000. That
expectation comes from the business rule and fixture, before the agent writes
the query.
A plausible generated query joins payments to refunds, then subtracts the summed
refunds from the summed payments. But Payment A appears once for each refund.
Its amount is counted twice, so the query returns 17000 instead of 7000.
An API test can catch that mistake without its author having to write the correct SQL first. A narrow database integration test using the same fixture helps the agent isolate the error and verify the corrected aggregation.
Further fixtures should return 10000 with no refunds, 0 with no settled
payments, and the same total when another customer's records are added. Those
assertions remain the contract when the agent rewrites the SQL.
The agent can write and revise the database-specific query. The engineer remains responsible for what the number means, which cases need verification, and why the evidence is sufficient for the change.
A reproducible SQL verification experiment
The standalone SQL experiment reproduces this aggregation mistake in an in-memory SQLite database. It contains a deliberately faulty join, a corrected query that aggregates refunds per payment, and explicit expected amounts defined in the fixtures.
Download the script and run it with Node.js 24:
node stack-agnostic-sql-verification.mjs
The experiment checks multiple refunds, no refunds, no settled payments, other
customers' records, pending refunds, equal-valued payments and refunds, and an
empty payment history. Equal-valued records matter because using
SUM(DISTINCT amount_cents) would incorrectly merge separate transactions with
the same amount.
On Linux with Node.js 24.18.1 and SQLite 3.53.3, the experiment produced this output on 26 October 2026:
Faulty join: expected=7000, actual=17000
PASS: two refunds for one payment; net_paid_cents=7000
PASS: no refunds; net_paid_cents=10000
PASS: no settled payments; net_paid_cents=0
PASS: other customers do not change the total; net_paid_cents=7000
PASS: pending refunds do not change the total; net_paid_cents=7000
PASS: equal-valued payments each count once; net_paid_cents=17000
PASS: equal-valued refunds each count once; net_paid_cents=8000
PASS: empty payment history; net_paid_cents=0
PASS: corrected query satisfies all 8 fixtures.
The script makes no network calls and writes no files. Its assertions check whether the SQL preserves the business contract. It does not run an AI agent, exercise an HTTP endpoint, establish production performance, or test concurrent transactions. Run the relevant checks against your actual database engine before relying on a query in production.
What if the AI generates inefficient SQL?
This is a legitimate concern, but it does not automatically imply that deep SQL expertise is required.
Suppose this endpoint also has an agreed target: p95 latency below 200 ms with a million payment rows, representative refund counts, and 20 concurrent requests. These are hypothetical acceptance criteria, not measured results from the SQL experiment. The small correctness fixture cannot establish them. A separate load test must exercise the same endpoint under those conditions.
If the application has appropriate instrumentation, the engineer can identify the problem through latency metrics and distributed traces.
The problematic query can then be investigated using database-specific diagnostic tools.
For PostgreSQL, for example, EXPLAIN and EXPLAIN ANALYZE expose execution
plans, estimated and actual row counts, execution timing, and other useful
information. Since EXPLAIN ANALYZE actually executes the statement,
potentially mutating queries must be investigated with appropriate precautions.
[8]
An engineer unfamiliar with PostgreSQL's query planner can use AI to explain the plan, identify plausible causes, investigate indexing strategies, or propose alternative queries.
The resulting changes can be evaluated using execution measurements, representative data, and the existing correctness tests.
The critical point is that the proposed optimization is validated empirically, rather than accepted because the model claims it should be faster.
Nor must the investigation necessarily wait until users experience poor performance.
Expected scale should be considered during design, and load tests should expose predictable bottlenecks before production when the associated risk justifies it.
But once the solution demonstrably meets its requirements with sufficient headroom, further optimization should be a conscious cost-benefit decision.
Knowing how to establish whether a query is sufficiently performant is more broadly useful than knowing how to manually optimize every SQL construct.
What about subtle correctness and concurrency problems?
Performance is the easier objection. Data correctness is more difficult.
A query may return an incorrect result without producing an error. Two concurrent transactions may individually appear correct but jointly violate a business invariant.
These problems cannot be solved merely by adding logs or optimizing queries when they become slow.
They require understanding the relevant consistency requirements and enforcing them appropriately.
For example, the engineer must recognize when an operation needs atomicity, when retries must be idempotent, and when concurrent state changes can produce unacceptable results.
The implementation might use transactions, constraints, locking, serializable isolation, or another mechanism appropriate for the system.
PostgreSQL's transaction isolation documentation illustrates how different isolation levels affect the anomalies an application must consider. [9]
An engineer does not need to have memorized PostgreSQL's implementation of these guarantees beforehand.
They do need to understand the underlying problem well enough to investigate which guarantees are required, how the selected database provides them, and how to verify the resulting behavior.
AI can assist with that investigation and implementation. Targeted concurrency tests, enforced invariants, and independent verification provide additional confidence.
For particularly complex or high-consequence cases, specialist review may still be appropriate.
But the need for occasional specialist expertise does not imply that every senior engineer must already possess that expertise across every database they might encounter.
What if the engineer doesn't know what to look for?
This is the strongest objection to the entire argument.
Someone who lacks sufficient technical understanding may fail to recognize important risks in the first place.
AI-generated reviews can also miss problems, especially when multiple agents reason from the same incomplete requirements.
There is no universal automated process that guarantees the discovery of every unknown unknown.
That is why stack-agnostic engineering still requires deep technical foundations, systematic research, and the ability to challenge assumptions.
It also requires judgment about the limits of available evidence.
An engineer should not treat familiarity with an AI tool as permission to ignore the complexities of an unfamiliar system.
Instead, they must be capable of identifying areas of uncertainty, investigating them, obtaining independent evidence, and involving additional expertise when necessary.
The important distinction is between needing to understand a technical risk and needing years of prior experience with the particular technology used to address it.
Those are not equivalent requirements.
When is stack-specific expertise still essential?
Deep stack expertise is essential when a decision depends on behavior that the team cannot investigate and verify within the available time and risk budget. An engineer's ability to learn quickly does not remove that constraint.
Examples include diagnosing a database failure during an incident, planning a destructive migration, investigating runtime-specific concurrency behavior, or reviewing a security boundary where an error could expose sensitive data.
The hiring decision should reflect how often that work occurs. If it is a central responsibility of the role, prior expertise may be a reasonable hiring requirement. If it is occasional, a capable senior engineer with access to specialist review may be the better fit. A team without dependable tests, observability, or recovery procedures also has less room to rely on learning the stack during delivery.
The assessment should therefore cover the candidate and the environment: what can this engineer establish independently, what support is available, and which decisions require expertise before work starts?
Conclusion: hire for engineering judgment
Deep stack experience remains valuable when diagnosing unusual failures, making decisions that are expensive to reverse, or working where mistakes have severe consequences. It can also shorten the learning curve.
But seniority should be judged by the engineer's ability to deliver and take responsibility for reliable software.
For a senior hire, I would look for someone who can:
- Turn an ambiguous request into explicit requirements.
- Investigate an unfamiliar stack and establish the guarantees it provides.
- Guide agents through bounded changes and verify results independently.
- Diagnose failures, recover safely, and recognize when specialist help is needed.
Those capabilities can be assessed through a concrete problem in an unfamiliar stack: what does the candidate clarify, what do they investigate, and what evidence do they require before accepting a solution?
Your next senior engineer needs the judgment to deliver reliable software. They can acquire the stack knowledge along the way.
References
- Michael Werle, "Become Builders, Not Coders."
- Martin Fowler, "Agentic Engineering."
- Mike Wacker, Google Testing Blog, "Just Say No to More End-to-End Tests."
- OpenTelemetry, "Observability primer."
- Google SRE, "Implementing SLOs."
- AWS, "Best Practices for Managing Data Synchronization and Schema Changes."
- Carlos Bueno, "The Mature Optimization Handbook."
- PostgreSQL, "Using EXPLAIN."
- PostgreSQL, "Transaction Isolation."