DEV Community: AI Feed

Will AI Replace Your Job? Use This 5-Part Task Test

AI Feed — Sat, 26 Sep 2026 22:36:15 +0000

The short answer: AI rarely absorbs an entire occupation at once. It reaches the tasks that are digital, repeatable, easy to verify, and cheap to get wrong first. The safest work combines judgment, accountability, relationships, or the physical world.

“Will AI replace my job?” sounds like a clear question. It is usually the wrong unit of analysis.

A job title is a bundle of very different activities. A marketer researches competitors, drafts copy, negotiates priorities, reads customer reactions, and owns a campaign result. A software engineer writes code, investigates failures, chooses trade-offs, reviews security, and is accountable when production breaks.

The model may be excellent at one activity and unreliable at the next.

The International Labour Organization reached a similar conclusion after mapping almost 30,000 occupational tasks: 25% of global employment is in occupations with some exposure to generative AI, but transformation is more likely than full replacement. Anthropic's observed usage data also found AI spread across tasks rather than evidence of whole jobs disappearing.

So instead of scoring a profession with one dramatic percentage, use this five-part test.

1. Is the task already digital?

AI adoption begins where the input and output already live on a screen.

Drafting an email, transforming a spreadsheet, producing a first code implementation, summarizing a contract, or classifying a support ticket requires no robot, warehouse, or visit to a client. The task can be placed directly inside a model's context.

Physical work changes more slowly. A model may prepare a maintenance checklist, but inspecting a noisy machine in an unfamiliar building is a different problem.

Higher exposure: writing, coding, research, reporting, document processing.

Lower exposure: installation, repair, bedside care, field inspection, hands-on craft.

2. Is the task repeatable?

Models perform best when a good answer resembles many previous answers.

A standard product description, a CRUD endpoint, a weekly report, or a routine invoice check has recognizable inputs and patterns. Novel strategy, an ambiguous incident, or a politically sensitive negotiation does not.

This is why the first visible change is often not job loss. It is the disappearance of routine work inside the job.

That creates a career problem: routine tasks were also where junior workers learned the domain. If companies automate every entry-level assignment, they still need a new way to develop future experts.

3. Can the result be checked quickly?

Automation becomes economical when errors are easy to detect.

Code can be compiled and tested.
A translation can be compared with the source.
Extracted fields can be validated against a schema.
A generated image can be judged immediately.

The same model is less useful when quality appears only months later. A weak hiring decision, a poor lesson plan, or a flawed architectural choice may look convincing on day one.

Verifiability often matters more than model intelligence. A company can delegate an imperfect task if it has a cheap, reliable check.

4. What happens when it is wrong?

Capability is not the same as deployability.

An AI-generated social caption can be reviewed and replaced. A medical decision, audit opinion, credit rejection, production deployment, or legal filing carries consequences that someone must own.

Regulation matters, but so do insurance, reputation, customer trust, and the cost of supervision. Even when AI can produce the answer, a business may still need a qualified person to approve it.

This is why accountability-heavy roles often change before they disappear. The professional handles fewer routine steps but remains responsible for the final decision.

5. Does the task depend on human context?

Models can process written context. They do not automatically possess the unwritten context of a team, a customer, or an organization.

Examples include:

knowing which stakeholder will block a technically correct decision;
recognizing that a patient is withholding information;
understanding why a supplier's delay is more serious than its email suggests;
deciding when a policy should make an exception;
earning enough trust to deliver difficult feedback.

The more a task depends on relationships, tacit knowledge, and responsibility for consequences, the more likely AI is to support a person rather than replace the role.

What changes first across common professions

Profession	AI reaches first	Human bottleneck remains
Software developer	Boilerplate, tests, refactoring, documentation	Architecture, security, debugging ambiguous failures
Designer	Variations, resizing, first concepts, asset cleanup	Art direction, taste, brand judgment, stakeholder alignment
Marketer	Research summaries, copy variants, reporting	Positioning, customer insight, channel trade-offs
Accountant	Classification, reconciliation, document extraction	Controls, exceptions, interpretation, sign-off
Teacher	Exercises, drafts, feedback preparation	Motivation, diagnosis, classroom judgment, safeguarding
Recruiter	Sourcing, summaries, scheduling, templates	Trust, persuasion, assessment, hiring accountability
Operations manager	Forecasting, routing, routine coordination	Escalation, conflicting priorities, real-world exceptions
Doctor or nurse	Documentation, search, triage support	Examination, consent, responsibility, human care

These are not permanent boundaries. They are current bottlenecks. Better models can move the line, while regulation, cost, and trust can hold it back.

Four patterns to expect

1. The profession stays, but the junior layer shrinks

When AI absorbs drafts and routine execution, one experienced worker can produce more. The occupation survives while fewer people are hired to perform its simplest tasks.

2. The role becomes more supervisory

People spend less time producing the first version and more time selecting, checking, integrating, and explaining. Judgment becomes more valuable; unverified output becomes cheaper.

3. Boundaries between roles weaken

A product manager can prototype. A designer can implement an interface. A developer can draft documentation and marketing experiments. AI lowers the cost of crossing into an adjacent discipline.

4. New demand appears around the automated system

Organizations still need people to structure knowledge, evaluate output, manage permissions, monitor failures, redesign processes, and decide where automation should stop.

A better question for your own career

List the ten activities that occupy most of your week. For each one, score these questions from 0 to 2:

Is the work fully digital?
Is it repeated in a recognizable pattern?
Can a good result be checked quickly?
Is the cost of an error low?
Does it require little relationship or physical context?

A task scoring 8–10 is a strong candidate for near-term automation.

A task scoring 4–7 is likely to become AI-assisted.

A task scoring 0–3 will usually remain human-led for longer.

This is a prioritization tool, not a forecast. The score changes with the organization, regulation, data access, and the quality of the surrounding system.

The labor market can grow and still feel more difficult

The World Economic Forum projects 170 million roles created and 92 million displaced by 2030 across several macrotrends, for a net increase of 78 million. That does not mean every worker moves smoothly from a declining task to a growing one.

New jobs may require different skills, exist in different places, or offer different pay. At the same time, organizations can need more software, analysis, and content while employing fewer people per unit of output.

Both statements can be true: more work is produced, and the entry path into some professions becomes narrower.

What to do now

Automate one repeatable task yourself. Learn what the system can and cannot do before someone redesigns the workflow for you.
Move closer to verification. Testing, editing, evaluation, and quality control gain value as generation becomes abundant.
Build domain knowledge. Generic production is easier to automate than understanding why a specific organization makes a decision.
Practice owning outcomes. The person who can choose a trade-off and accept responsibility remains harder to replace than the person who only produces a draft.
Learn adjacent work. AI rewards people who can connect product, data, operations, design, and implementation.

Explore 30 professions

AI Feed's Work Atlas applies this approach to 30 occupations. Each profile separates tasks suited to AI from human responsibilities and shows how the role connects to adjacent work.

Use it as a map of changing tasks, not a countdown to a profession's disappearance.

Sources and limits

The framework above is an editorial interpretation of task characteristics. Exposure does not equal adoption, and adoption does not automatically equal job loss. Company data, integration cost, regulation, demand, and worker bargaining power all affect the outcome.

Updated September 27, 2026.

Best Local AI Models for Mac by RAM (8GB–128GB)

AI Feed — Sat, 26 Sep 2026 22:23:20 +0000

The short answer: choose a Mac for local AI by unified memory first and chip generation second. Keep at least 25–30% of memory free for macOS, context, and the applications you actually use.

A model that loads is not automatically a model that runs comfortably. This guide maps Mac memory tiers to realistic model sizes without treating a benchmark score as a buying recommendation.

Quick recommendations

8GB: compact 2–4B models for short prompts, classification, and extraction.
16GB: general 7–9B models; 20B can run close to the limit.
24GB: the practical mainstream tier for 9–20B models.
36–48GB: the balanced range for 27–35B, coding, and document work.
64GB: 70B at 4-bit becomes practical.
96–128GB: large 70–120B models, long context, and parallel workloads.

Use the AI Feed Local AI monitor to compare current models by memory, license, and task.

Mac memory guide

Mac memory	Comfortable model class	Best fit	Main constraint
8GB	2–4B Q4	Short chat, extraction	Very little context headroom
16GB	7–9B Q4/Q6	Writing, documents, light coding	20B runs close to the limit
24GB	14–20B; selected 27B Q4	Coding, RAG, daily assistant	27B needs moderate context
36GB	27–35B Q4	Serious coding, agents	Long context still consumes memory
48GB	35B Q6; reduced 70B	Large repositories, multiple agents	Full 70B remains tight
64GB	70B Q4	Complex analysis and coding	Smaller MoE models may be faster
96–128GB	70B high precision; 120B class	Long context, serving workloads	High hardware cost

These are practical headroom targets, not hard limits. Actual use changes with quantization, runtime, and context length.

Why memory matters more than the chip badge

Apple Silicon uses unified memory: the CPU and GPU share one pool. That helps local inference because the accelerator can access most of the machine's memory without copying weights into separate VRAM.

The trade-off is competition. Model weights, Safari, an IDE, Docker, the display system, and the KV cache all use the same pool. When weights consume nearly everything, macOS swaps, generation slows, and a longer prompt can terminate the process.

Memory needed = weights + KV cache + compute buffers + runtime + macOS + apps

Weights are the large predictable component. Q4 uses roughly half a byte per parameter, plus overhead.
KV cache grows with the conversation and context window.
Compute buffers depend on architecture and runtime.
The system still needs room for your browser, editor, and background services.

That is why a 17GB model file may run on a 24GB Mac but feel much better on a 36GB machine.

What each memory tier is good for

8GB: small models only

Look at 2–4B variants of Qwen, Phi, Gemma, and similar families below roughly 3–4GB. They are useful for classification, field extraction, short rewrites, and simple completion. They are not a realistic choice for a large codebase or long documents.

16GB: the entry point

Modern 7–9B Q4/Q5 models can edit text, answer over local documents, and help with small functions. OpenAI says gpt-oss-20b can run within 16GB, but that leaves little room for context and applications. Possible is not the same as comfortable.

24GB: the practical mainstream choice

For most buyers, this is the first genuinely useful local AI configuration. It can keep a strong 9–14B model resident alongside a browser and editor, or run gpt-oss-20b with reasonable headroom.

Practical choices include:

a modern 9B model for an everyday assistant;
gpt-oss-20b for reasoning and agentic tasks;
a 27B Q4 model as an upper-edge experiment with moderate context;
a 9–20B model paired with a capable coding harness.

36GB and 48GB: the developer sweet spot

Models in the 27–35B class leave room for context, an IDE, and a browser. At 48GB, higher-quality quantization or multiple processes become practical.

More GPU cores make a model faster. More memory changes which class of model can run at all. For many developers, that makes 36–48GB more valuable than a faster chip paired with less memory.

64GB: practical 70B inference

At 64GB, 70B models in Q4 become realistic. Their weights commonly occupy around 42–48GB, leaving limited but workable headroom.

More parameters do not automatically mean a better experience. A modern 35B MoE model can be faster and more reliable with tools than an older dense 70B model.

96GB and 128GB: workstation territory

These capacities make sense when you intentionally need very large models, several simultaneous clients, or long context. OpenAI estimates gpt-oss-120b at roughly 80GB, so 96GB is the practical starting point and 128GB leaves useful application headroom.

For occasional demanding jobs, a cloud model can still be faster and cheaper. The AI Feed API price calculator helps compare the order of cost.

Ollama, MLX, or llama.cpp?

Runtime	Best when	Strength	Trade-off
Ollama	You want the simplest setup	Model library and local API	Less tuning control
MLX / MLX-LM	A good Apple Silicon conversion exists	Native unified-memory design	New conversions may take time
llama.cpp	You need GGUF and detailed tuning	Portability and Metal support	More manual setup

Start with Ollama or LM Studio. Try MLX when a reliable conversion exists. Use llama.cpp when you want direct control over context, cache, offload, and server settings.

Coding, images, and video are different workloads

Coding

Instruction following, repository access, and tool use matter as much as model size. A good 9–20B model with a coding harness is usually more useful than a larger model with no context headroom.

Images

Diffusion models use memory differently from LLMs. Compact generators run at 16–24GB, while high resolution, multiple ControlNets, and batches need more.

Video

Local video remains the heaviest workload. A 24–36GB Mac can run compact models for short clips with long waits, but it is not equivalent to a cloud video service.

A five-step buying rule

Define the workload. Chat, coding, retrieval, images, and video need different hardware.
Choose the model class. Start with 9–20B for daily work; not everyone needs 35B.
Find the quantized file size. Check Ollama, MLX Community, or a GGUF repository.
Add 25–30% headroom. Add more for long context, Docker, and a heavy IDE.
Compare chips last. With equal memory, Max is faster than Pro, but it cannot run a model that does not fit.

Buying recommendation

16GB for learning and small local models.

24GB as the practical minimum for regular use.

36–48GB for developers, agents, and 27–35B models.

64GB when you specifically need 70B or concurrent models.

96–128GB for a workstation or home server.

Sources

Updated September 25, 2026. Sizes refer to specific quantizations and may change as runtimes evolve.

Compare current models with the Local AI model selector. The original article and future updates remain on AI Feed.