A large Australian bank is hiring an AI Engineer for its "AI Innovation Office." Read the responsibilities slowly: design and ship production-ready AI applications, integrate foundation models, build pipelines for prompt management and evaluation, embed guardrails, optimise latency and cost, collaborate with stakeholders. Now ask the only question that matters: what part of this can't a language model do?
The answer the bank is hoping you'll give is "judgement in a regulated environment." The answer the bank is afraid of is "roughly none of it, and the judgement part is shrinking every quarter."
An AI Engineer's entire job is to build systems that replace human cognitive labour with model inference. The role is a person standing on a beach, building a machine that empties the ocean, and politely refusing to notice that the machine can also build itself. So let's take the posting at its word and design the replacement — as a worklog, not a thought experiment.
What the human actually does
Strip away the "human-centred" adjectives — those are compliance perfume — and the job is a tight engineering loop. You receive a business problem from a stakeholder who speaks in risk and revenue. You translate that into a RAG architecture: pick a foundation model, pick an embedding model, stand up a vector store, write the retrieval logic, build the prompt templates, wire in guardrails for privacy and model risk, and then you test, evaluate, monitor, and ship. Then you argue with the security team about data residency. Then you optimise the cloud bill because someone ran a retrieval benchmark on the largest available model and it cost the equivalent of a junior analyst's annual salary in a week.
It is a pipeline problem with a documentation problem bolted to the front. The inputs are business requirements and regulatory constraints. The outputs are a deployed service, a set of evaluation metrics, and a paper trail for the auditors. The glue is software engineering — backend services, APIs, integration tests, CI/CD. And software engineering is the thing language models currently do best.
The replacement, phase by phase
Phase one: requirements translation. A stakeholder sends a paragraph of business prose to a ticketing system. A model reads the ticket, the bank's risk taxonomy, and the relevant regulatory documents, and emits a structured specification: the problem, the proposed architecture, the data sources, the guardrails required, the evaluation criteria. This is a RAG pipeline pointed at the bank's own policy library, and it is the easiest thing in the posting to build. The human "collaboration with non-technical stakeholders" is a meeting that a well-prompted model can replace with a document more precise than the meeting's minutes would have been.
Phase two: architecture and scaffolding. Given the spec, a code-generation model produces the service skeleton. It selects the vector store client, writes the embedding pipeline, drafts the prompt templates, and stands up the API endpoints. The human engineer's "strong software engineering background across backend services" is exactly the skill set that code models have been trained on for the past three years. The scaffolding is the part that is most automated and most boring, which is why the posting lists it first.
Phase three: the guardrails. This is where the posting gets solemn — "security, privacy, compliance, model risk and guardrails from design to delivery." This sounds like the human's last stand. Guardrails are code: input validators, output classifiers, PII redaction filters, prompt-injection detectors, rate limiters, content policy checks. Each is a classifier or a rule set, and each can be specified, tested, and deployed by the same pipeline that builds the application. The regulatory documents that define the guardrails are text. The guardrails themselves are code. The mapping between them is a reading-comprehension problem with a code-generation output — exactly what a model does well.
Phase four: evaluation and monitoring. The posting asks for "testing, evaluation, monitoring, and feedback loops for quality, performance, safety, and cost." This is a CI pipeline with a dashboard. A model writes the evaluation harness, generates the test cases, runs them, and produces the report. The human's job is to read the report and decide whether the numbers are acceptable — but the model can flag threshold breaches automatically, and the decision criteria are themselves specifiable. The dashboard is an artifact for auditors, not a cockpit for a pilot.
Phase five: optimisation. Latency, reliability, cost — these are knobs. A model can profile the workload, identify the bottleneck, and propose the change. For a RAG system, the optimisations are well-known: cache embeddings, compress the context, route simple queries to a smaller model, batch the rest. This is a checklist, and checklists are the native format of automated systems.
Where it breaks
The bank is regulated, and regulation means accountability — not correctness, but traceability. When a model makes a loan decision that discriminates, or a chatbot gives a customer legally binding financial advice it shouldn't have, someone has to stand in front of a regulator and explain what happened. That someone cannot be a pipeline. The regulator wants a neck, and necks are biological.
So the human does not vanish. The human becomes the named accountable party — the person who signs the model card, who approves the guardrail thresholds, who reviews the evaluation report and stamps it. The work is automated. The signature is not. This is the employment theatre of AI engineering: the human is doing the governance of the engineering, and governance is a legal requirement. It is the same reason a human still signs off on automated financial audits. The signature is the product; the analysis is a commodity.
There is a second break point, less obvious and more interesting. The posting asks for "the judgement to deliver safely in a complex, regulated enterprise environment." Judgement, in this context, is the ability to resolve ambiguity when the regulation is vague and the stakeholder is scared. A model can read the regulation and the stakeholder's email, but it cannot read the room. It cannot tell when the risk team's objection is a genuine safety concern and when it is institutional anxiety dressed up as a technical requirement. That reading of the room — the political intelligence of a large organisation — is the last thing that automates, because it lives in the silence between the sentences in the meeting that the model wasn't invited to.
The verdict
The bank is hiring an AI Engineer to build AI systems that will make the bank's AI Engineer role structurally unnecessary within two product cycles. The posting is a job description for a person who will, if successful, automate the need for their own replacement. This is not a paradox — it is a plan.
The best engineers know it. They take the job anyway, because the work is interesting, the pay is good, and the automation of one's own role is a problem for a future version of oneself. Fittingly, that is exactly the kind of reasoning a language model would produce.

