Everyone must become an Individual Contributor ("IC") Manifesto

The AI-Native Individual Contributor Manifesto, by Shahid N. Shah

AI can now summarize, code, reason, and even create new ideas at scale. This powerful new “co-pilot” means the barrier between thinking of an idea and seeing it built is collapsing. Non-technical workers can prompt AI tools like ChatGPT, Claude, or Figma/Lovable to instantly draft reports, designs, or prototypes. Suddenly, everyone – from the VP of Sales to the CFO to the marketing associate – can contribute directly to the deliverable, rather than just assigning it out.

If we want to survive in a post-AI-native world we must all become Individual Contributors (ICs). An IC traditionally means someone who drives work forward by doing the work itself. Today, even managers and leaders become ICs by crafting precise prompts and AI-driven prototypes, rather than delegating. Our new “programming language” is natural language prompts and context-engineering artifacts. We no longer just describe tasks in vague documents or handoffs – we write executable prompts that generate concrete results. As one observer notes, we are building little “libraries of prompts” that contain “the secrets to how we each do our jobs,” requiring tools to create, share, update, and run them.

Generative AI demands a new mindset. Creativity is the bottleneck now, not code. As one practitioner observes, “when there is no longer a ‘technical person’ required… the limitation is not code, but creativity. All you need to know is what you want to do, and then write it in natural language. An LLM can do the rest now.” This means our focus moves upstream: instead of writing code, we write the right prompts and context. This requires everyone to learn “context engineering” – designing the right information and instructions for AI agents – so they have everything they need to accomplish a task.

Simply put, the game has changed. In the old world, work trickled down from executives through managers to teams in linear hand-offs (via emails, slide decks, Jira tickets, etc.). In the new world, everyone participates early and directly by scripting prompts and prototypes. Every department becomes a source of executable ideas. In the sections below, we detail exactly how this plays out in each function.

Executive Leadership: Strategy is a Prompt

• Old world: CEOs and executives set the vision with strategy documents and speeches. They might send a PowerPoint deck, an email memo, or a quarterly roadmap to their organization. These are interpreted, reworded, and handed off down the chain, often losing clarity and precision along the way. The strategy lives in slides or PDFs – static, ambiguous, and siloed.
• New world: Executives become chief prompt architects ("head of context engineering"). After engaging with customers and the market, they distill strategy into system-level prompts that any AI agent can use. Instead of a slide deck on “digital transformation,” the CEO produces an explicit AI prompt (or set of prompts) capturing the company’s goals, context, and constraints. For example, an executive might interact with a generative AI to craft a “superprompt” that reads the executive’s vision and outputs a detailed strategic plan tailored for each department. This prompt, reusable and shareable, becomes the ultimate strategy document. It might feed into an AI that generates weekly updates or suggests new initiatives consistent with the vision.
• Why it matters: By couching strategy in prompts, executives ensure that every team member and AI agent gets the exact same guidance. There are no lost messages in translation. It also means strategy can be dynamically updated and distributed: if the market changes, the leader just tweaks the prompt and instantly propagates the new plan. Everyone – from the CTO down to the sales rep – works off the same “code” (prompt) of strategy. In effect, “Strategy is a prompt,” echoing the old maxim that “a good plan is executable.” This is how executives govern by example, not just by command. (Forbes-level leaders now invest in creating libraries of strategic prompts as valuable IP for their companies.)

Business Development: Prompts are the New SOWs

• Old world: Business development teams and sales reps craft statements of work (SOWs) or project briefs outlining customer needs. They spend weeks gathering requirements from clients, then write up detailed documents or PowerPoint decks to hand off to delivery teams. Typically, these SOWs are formal documents or slide decks that (hopefully) capture the client’s scope, but they often leave gaps and ambiguities.
• New world: BD teams become AI-powered business analysts. Rather than just writing a PDF SOW, a BD lead interacts with a generative AI (like ChatGPT or Copilot for business) to encode the customer’s requirements directly into prompts and data. The BD person interviews the client as before, but then quickly distills those conversations into a prompt or series of prompts for an AI. For example, they might input key points from a discovery call into an AI tool and ask it to generate a detailed product requirements draft. The result is a refined prompt-based specification that captures the client’s needs as actionable instructions. This prompt can then be handed directly to engineers or used to generate mockups on the fly.
• Concrete example: Suppose a client needs an internal tool for invoice management. In the old model, the BD writes an SOW: bullet points, requirements list, and maybe a timeline. In the AI-native model, the BD instead tells ChatGPT (with the client info): “Imagine we need an invoice management app for a finance team. The user persona is an accountant at a mid-size company. Requirements: track invoices from supplier, approve payments, integrate with bank API. Generate a preliminary feature list and wireframe description.” The AI returns a structured response – essentially a draft SOW – which the BD reviews and refines. That final prompt (and even a quick generated wireframe) becomes the deliverable handed off.
• Why it matters: The BD’s output is now immediately actionable. The prompt/draft SOW can feed directly into design and development. There’s no separate hand-off interpretation step: the next person simply uses the prompt as the “code” to work from. It also means every BD hire is being trained as a mini prompt-engineer – they learn to ask for exactly the right output from AI. For the organization, that means sales cycles accelerate and we can say “yes” to clients faster. Ambiguity is reduced because we’re using AI to simulate the product immediately and clarify gaps early.

Project Delivery Leaders: From Jira to Prompts

Read more at Project Delivery Leaders Shift Left on AI Projects and Project Delivery Leaders Shift Left on Legacy Projects & Plus we've got a useful Checklist for Project Delivery Leaders to help Shift Left.

• Old world: Project managers and delivery leads manage pipelines via tickets and tasks. They write Jira tickets or Asana tasks describing features (“Implement checkout page”) and then coordinate teams via emails and meetings. Kickoff often means a discovery phase full of docs, followed by handing off tasks to developers and waiting for questions.

• New world: Delivery leaders become prompt-driven orchestrators. Instead of issuing tickets or sending long emails, they create and refine AI prompts that can generate drafts of the actual work items. For example, rather than writing a ticket for a checkout feature, a delivery lead might work with an AI tool (or use a prompt management platform) to refine a prompt like: “Write React code for a checkout form with fields for item, quantity, price, and a Pay button. Style with our brand colors. Include form validation.” The AI then outputs a code stub or detailed design mockup. The delivery lead reviews this output, iterates by adjusting the prompt, and when satisfied, hands that prompt (plus any generated artifacts) to developers and designers.

• Concrete example: In practice, a delivery lead could maintain a “prompt backlog” alongside the usual backlog. Each backlog item is not just a sentence but a fully-honed prompt (possibly with examples or reference designs embedded). For a feature like “user login,” the manager might prompt the AI to produce a prototype UI in Figma or code in React. The team then starts from that prototype, not from zero. Project kickoff might involve an AI-run simulation: the PM prompts an AI to outline user stories and acceptance criteria given the project brief, creating a living test plan.

• Why it matters: Work no longer cascades in linear waves. Instead, every project starts with a semi-executable prototype in hand, thanks to AI. This drastically cuts ambiguity and rework. Developers get AI-generated starter code or detailed specs tailored to the exact requirements. Designers get AI-generated mockups keyed to the brand. QA leads get AI-suggested test cases. In effect, “tickets become prompts” – and the prompts are as deliverable as code. The project timeline compresses because the most laborious part (spec writing and prototyping) is accelerated by AI.

Marketing Teams: From Briefs to AI Prototypes

• Old world: Marketers brainstorm campaign ideas, then write creative briefs for designers: “We want a modern landing page for product X focusing on youthful energy.” They might hand off images to designers or content drafts to copywriters. Often the handoffs are broad (“Here are some keywords”) with guesswork on execution.
• New world: Marketing people become prompt-artists and prototype-makers. Using AI tools like Lovable (lovable.dev) or ChatGPT plus design AI, they can generate entire draft assets by prompt. For instance, instead of telling a graphic designer to create a banner, the marketer simply talks to an AI: “Design a vibrant web banner for our new sports app launch, featuring a smiling young person using the app, with bold orange and teal color scheme. Include the tagline: ‘Play smarter, live better.’” The AI (or a plugin like Lovable) churns out a polished graphic or layout. That output serves as a concrete prototype for designers or developers.
• Concrete example: Lovable.dev’s website advertises exactly this: “Build something lovable – Create apps and websites by chatting with AI”. A marketer can use Lovable to spin up a draft homepage in minutes, based solely on a short text prompt about the campaign. Similarly, copywriters ask ChatGPT for email subject lines or ad copy and then tweak the AI’s suggestions. These AI-generated drafts are the new creative briefs. The refined prompts and prototypes are then handed to designers as starting points.
• Why it matters: Marketing workflows flip from descriptive instructions to instant prototypes. Designers no longer start from a blank canvas; they edit and polish what AI created. Marketers iterate in real time on campaigns by re-prompting AI until the mood and message are spot-on. Collaboration speeds up because the hand-off is clear – a visual asset plus the exact prompt that generated it. The marketing team itself becomes more agile: launching and A/B testing campaigns quicker than ever, since generating fresh creative is just a few prompts away.

Architects: Blueprints as Prompts

Read more at Architects Shift Left on AI Projects and Architects Shift Left on Legacy Projects & Plus we've got a useful Checklist for Architects to help Shift Left.

• Old world: System and solution architects produce high-level design documents or guidelines. They create abstract diagrams (cloud infrastructure diagrams, UMLs, API outlines) to guide development. These are often static documents that developers refer to, but which can be vague or become outdated by the time code is written.

• New world: Architects become prototype-builders and prompt-curators. Rather than only writing text docs, an architect now generates actual code prototypes or AI-driven simulations to validate ideas. For example, an architect might ask an AI coding assistant (like GitHub Copilot or an OpenAI Codex agent) to write a sample microservice or Terraform script based on the system requirements. They iterate on prompts to refine the design. The result might be a half-baked app or infrastructure as code that proves a concept. These artifacts (plus the prompts used) are passed to developers.

• Concrete example: If designing a new API, an architect could prompt ChatGPT: “Generate a Node.js Express server that has endpoints for creating, reading, updating, and deleting customer records. Use a MongoDB database and JWT authentication.” The AI returns scaffold code. The architect reviews, tweaks the prompt, or adds examples (“explain each function for a developer in comments”), and the process continues until the output meets the specification. Now developers have a real codebase to work from, not just a diagram. Architects might also use tools like LangChain to prototype multi-step AI workflows as proof-of-concept.

• Why it matters: Architects ensure feasibility early and concretely. Instead of abstract theories, they hand off runnable blueprints. This is “shifting architecture left” – catching design issues before they reach the coding stage. It also democratizes architecture: teams can collaborate on these AI-driven prototypes, and even non-experts can suggest improvements via prompts. In short, architecture documents become living, AI-augmented code artifacts. This cuts the gap between design and implementation and reduces “translation losses” when going from concept to code.

Project Managers & QA: Simulate UAT with Prompts

If this piqued your interest, read more at PMs & QA Shift Left on AI Projects and PMs & QA Shift Left on Legacy Projects. Plus we've got a useful Checklist for PMs and QAs to help Shift Left

• Old world: PMs and QA leads coordinate via meetings and static documents. They collect requirements, write project plans, and plan user acceptance testing (UAT) with checklists. Test plans and bug reports are often manually written, and developers question managers endlessly to clarify acceptance criteria.
• New world: PMs and QA leaders transform into AI-driven test planners and coordinators. Instead of waiting for dev to propose code, PMs use AI to simulate the final product and its tests. They write prompts to create virtual UAT plans, acceptance criteria, and even mock user dialogues. For instance, given a product feature, a QA lead might ask an AI: “Act as an end user and test this feature: I click ‘Order Now’ on the app and enter payment details. Write down what should happen at each step and what can go wrong.” The AI outputs a detailed UAT scenario. PMs iterate on prompts until the test cases cover all user stories. These AI-generated test plans become living documents, automatically updated as requirements change.
• Concrete example: During a sprint planning meeting, instead of scribbling notes, a PM could use ChatGPT to flesh out a story’s acceptance criteria. They might say: “Given a logged-in user with insufficient funds, what errors should appear when they try to purchase an item at $50?” The AI answers with specific UI messages, flows, and even JSON error codes. The team can validate these with stakeholders immediately. Similarly, QA can feed the AI basic specs and get back test scripts or even code for automated tests.
• Why it matters: By codifying tests and plans as prompts, PMs and QA “shift left” into the development phase. Developers see exactly what the customer experience should be from day one. This alignment cuts back-and-forth: everyone knows the “definition of done” is embedded in the prompt. And because prompts can include any business rules, compliance checks, or edge cases, QA coverage improves. In effect, managing becomes not just coordination, but also prompt crafting – ensuring that every task handed to development is already specified in natural language and context.

Developers: The Prompt is the New Code

Read more at Developers Shift Left on AI Projects and Developers Shift Left on Legacy Projects.

• Old world: Developers have been the technical backbone, writing code in programming languages, integrating systems, and implementing features from specifications. They often worked as ICs already, but with a clear division of labor: others define what to build, and devs build it. The hand-off was traditional specs or tickets.

• New world: Developers evolve into AI-co-creators and prompt architects. Much of the low-level coding can now be auto-generated by AI; developers focus on system design, validation, and “prompt debugging.” In practice, a developer’s first step for any task may be to prototype with AI: feed the refined prompt from BD/PM into a coding assistant (GitHub Copilot, ChatGPT with code, etc.) and review the generated code. The developer then adjusts the prompt (“rewrite this to use our auth middleware”) or adds custom code where needed. The result: developers write fewer boilerplate lines and more high-level logic and integration.

• Concrete example: If tasked with implementing a new API, the developer might start by taking the architect’s prompt (from the architecture section) and running it through an AI agent. The AI produces a starter project. The developer reviews for correctness, security, and compliance. When issues arise, they often arise from ambiguous prompts, so the developer now also sharpens prompts. They may even write automated tests by prompting the AI (“Write a unit test in Jest for the user registration function”).

• Why it matters: Developers become true ICs in the sense that there is no “handing off to developer” anymore – rather, developers work in concert with AI from day one. The programming language of the project is partly English + specific instructions, not just Java or Python. This boosts productivity immensely: code is generated 10x faster, and bugs from specification gaps shrink. It also flips the skillset: the future “10x developer” is one who “manipulates AI to produce the best output with the best prompt,” as one tech leader quipped thesignal.club . Developers still ensure quality and handle complex logic, but they spend far less time on trivial code, allowing teams to deliver faster and focus on innovation.

Key Themes: Shifting Left and Prompts as Currency

These examples share a single unified transformation: Everyone shifts left, and prompts become the currency of work. In the traditional model, tasks flowed in a line: executives define strategy → middle managers translate → teams execute. In the AI-native model, that line collapses. From top to bottom, everyone participates directly by writing prompts and prototypes (not just documents).

Shift Left Everywhere: Every role now engages at the earliest possible stage by crafting execution-ready prompts. Sales doesn’t just sell; they start building AI-enhanced demos. Architects don’t just design; they generate code sketches. QA doesn’t just test; they pre-write acceptance scenarios. By pushing work “to the left,” we eliminate wasteful queues and delays. (This is the same mindset as shift-left testing, but applied across the enterprise.)

Prompts as Deliverables: The primary artifacts of collaboration are no longer slide decks or Excel spreadsheets, but prompts and AI context packages. A completed work item might be a prompt template, a dialogue flow, a language model input chain, or an AI-generated prototype. Just as code once went into version control, now we’ll store and iterate on prompt libraries. These are the new SOWs, new spec documents, and even new contracts. As one expert puts it, “the best prompts will be valuable IP… as critical as the code bases of the last few decades”.

Everyone is an IC: In practice, every person - from the C-suite to a junior analyst - is now directly driving outcomes, not merely managing them. There are no more vague handoffs where one department “does the thinking” and another “does the doing.” Instead, the thinking and doing happen together, via AI. This is why we say “Everyone is an IC.” It’s a cultural as well as technical shift: teams become a flat ecosystem of thinkers and executors, collaborating through AI prompts rather than hierarchies.

No More Linear Hand-offs: Work is no longer a waterfall from left to right. The pipeline becomes collaborative and dynamic. A marketing prompt instantly produces a design that a dev can tweak, which instantly produces test cases that go back to designers, all in a fluid loop. This breaks down silos: when marketing and engineering speak the same “prompt language,” misunderstandings evaporate.

Acceleration of Delivery: Perhaps most importantly, prompt-driven workflows supercharge speed. When each hand-off is a fully-executable prompt rather than an incomplete spec, teams spend far less time clarifying requirements. Prototypes and code appear almost instantaneously. When companies internalize that “prompts are the new currency,” they unlock a step-change in productivity. Testing and iteration happen in real time. Delivery cycles shrink from quarters to weeks or days. The role of management pivots to ensuring we have a rich context and clear prompts for the AI, so that everyone can execute with confidence.

Call to Action: Embrace the AI-IC Era

Everyone must become an IC. The era of corner offices delegating tasks is over. Whether you work in HR, finance, legal, or product – think of yourself as a builder, not just a coordinator. Learn to articulate your goals as prompts. If you write emails or powerpoint decks today, start writing prompts or prototype specs instead.

Prompts are the new programming language. Treat natural language not as a fallback, but as the code you master. Get fluent in describing your needs precisely for AI. Encourage your teams to keep a “library of prompts” (just as one tech leader advises). Use prompt-engineering tools and platforms: from ChatGPT to specialized UI prototyping AIs (like Lovable) to coding assistants (like Copilot and Replit). Internal training should include targeted prompt engineering courses for each role – managers, salespeople, developers alike.

The currency of hand-offs is prompts, not documents. Replace vague deliverables with detailed prompts and AI-context bundles. If you used to email a spec, now create a prompt (with examples, data, and context) that generates the spec. Share prompts in your collaboration tools. Version-control them. Treat them as intellectual property: your competitive edge may live in the prompts you craft.

Shift left and iterate in context. In every meeting or discussion, ask: “Can an AI do this now?” If yes, let your AI assistant start the first draft. Review and refine it. Accelerate feedback cycles: test your ideas through AI before committing resources. This minimizes risk and rework.

Act now – the future is prompt. The technology is here, and the winners will be those who learn this new paradigm fastest. As one practitioner put it, the key to success is imagination: replace fear of AI with its creative potential. Start small: pilot AI-prototyping in one part of the business today. Encourage experimentation. Build a culture that shares prompt tips across teams. Remember: this isn’t just a technical change, it’s a business transformation. By embracing prompt-driven work, you’re not just optimizing a process – you’re rewiring your organization for the AI age.

The future of consulting, technology, and product development is clear: Everyone is an AI Individual Contributor, and our language of work is natural language prompts. Those who pivot now – re-skilling people as prompt engineers, rewriting the playbook so that the handoff is a prompt – will find their organizations vastly more agile, creative, and competitive. This is our manifesto and our challenge: let’s shift left, write the prompt, and build the future together.