TL;DR: AI tools amplify what you already know. Practitioners with strong fundamentals in design, photography, writing, or software engineering get better results because they understand what good looks like and can guide the machine toward it. Skipping the fundamentals because AI exists is a shortcut that quietly compounds into a ceiling.
A junior designer and a senior designer can type the same prompt into the same image generator and get wildly different results. Not because one of them used better punctuation, but because one of them has spent fifteen years studying composition, lighting, and balance, and can describe what they want in language the model can translate into something good. The other can describe what they want in language the model has to guess at.
This pattern is showing up everywhere. AI tools are powerful, fast, and getting better every quarter. They are also, almost without exception, multipliers. They take what the operator brings to the table and scale it up. The question, then, is not whether to use them. The question is what someone is bringing to the table when they do, and that is where fundamentals in the age of AI become the quiet advantage.
AI tools amplify intent, vocabulary, and judgment. They do not supply them.
A model generating an image has no idea what “good” means until someone tells it. A coding assistant cannot decide whether a function belongs in a service layer or a controller; it can only suggest patterns it has seen before. A writing assistant can produce three drafts of an email in seconds, but it cannot tell which one sounds like the person who needs to send it.
What flows out of these tools is shaped by what flows in. The operator who knows the rule of thirds writes a prompt that includes it. The operator who has read good code recognizes a bad suggestion when it appears. The operator who has shipped real products knows which features will collapse under real-world load. Every one of those signals comes from the human, not the model. The model just runs faster.
Experienced practitioners get better results because they can describe outcomes precisely, recognize quality immediately, and correct course before the work drifts.
Take photography. A photographer who has worked with strobes, reflectors, and natural light for a decade can look at an AI-generated image and instantly name what is wrong with it. The catchlights are in the wrong eye. The shadow falloff suggests a key light that does not match the rim. The lens compression implies an 85mm portrait lens, but the depth of field reads more like a 35mm at f/2. They return to the prompt, adjust two or three words, and the next render is meaningfully closer.
Someone without that vocabulary sees that the image looks “off” and types “make it better.” The model has no idea what better means.
The same principle applies across every creative and technical domain. Graphic designers who have studied typography write prompts that specify x-height, leading, and counter-shape. Cinematographers describe lighting setups by name. Skilled writers can identify when a paragraph is hedging and ask for a more confident voice. Fundamentals are not a nostalgia exercise. They are the language layer that lets a practitioner steer the tool with intention.
In software development, fundamentals are the durable concepts that survive every framework cycle: how data moves through a system, how state is managed, how errors propagate, how a request becomes a response, how a system fails, and how to read code that someone else wrote.
A developer with these fundamentals can use a coding assistant as a force multiplier. They describe what they want in terms the tool can act on: “Refactor this controller to delegate to a service object, and make sure the existing integration tests still pass.” They read a 200-line generated patch and spot the subtle null-handling bug on line 142. They can ask the assistant to build an agent skill and know whether what came back will actually work in production.
A developer without those fundamentals is in a different position. They can describe what they want in terms of outcomes, like “build me a login page,” but they cannot evaluate the result with any confidence. They cannot tell whether the generated code is idiomatic, secure, performant, or maintainable. They are accepting the output on faith, and the moment something breaks, they are stuck.
The same divide exists for anyone building agents, designing prompts, or wiring up tools. A practitioner who has shipped a real application understands why a tool call needs idempotency, why a long-running task needs a queue, why a context window has limits. A practitioner who has not, often does not, and the agent they build reflects it.
AI tools are very good at producing output. They are not, on their own, good at producing outcomes.
Output is the thing that comes out: an image, a function, a page of copy, a UI mockup. Outcome is whether that thing solves a real problem for a real user. Closing the gap between the two is where fundamentals do their heaviest work.
A landing page that an AI generates in thirty seconds might look fine. Whether it converts depends on whether the person reviewing it understands hierarchy, scan patterns, and message clarity. A backend service that an AI scaffolds in five minutes might pass its tests. Whether it scales depends on whether the person reviewing it understands the trade-offs between consistency and availability. A prompt that returns a usable answer in one context might fail in another. Whether someone catches that depends on whether they understand how the model is actually behaving.
Without fundamentals, the operator becomes a passenger. The work gets done, but it gets done at the level of the tool’s defaults, not at the level the project actually requires.
The honest answer is that fundamentals are built by doing the slow work that AI tools were designed to skip.
That means reading code that someone else wrote rather than generating new code on top of it. It means looking at photographs that were composed by hand, then asking why they work. It means writing a function from scratch before asking an assistant to optimize it, studying typography from a book that was set before LLMs existed, and building one small application, end to end, without a coding assistant, just to feel how the pieces actually fit together.
It also means using AI tools deliberately, not reflexively. There is a difference between asking an assistant to generate something the operator does not understand and asking it to accelerate something the operator already does. The first is borrowing capability. The second is using a tool. The first has a low ceiling, because the practitioner can only ever steer toward what they can already recognize as good. The second has a much higher ceiling, because the practitioner keeps growing while the tool keeps getting faster.
The practitioners who will get the most out of AI over the next decade are not the ones who lean on it hardest. They are the ones who built a foundation before the tools arrived, or who are willing to build one now, even though the shortcuts are right there.
Issue five of The Product Stack. This week: a desktop app framework that finally makes Electron feel optional, a privacy-first file transfer tool, the next chapter of HTMX, the self-hosted LLM UI that everyone is running, a fast-growing community for Claude Code users, and a voxel renderer that has no right being this fun. Let’s get into it.
Tauri is a framework for building native desktop and mobile applications using web front-end technologies. Where Electron ships a full copy of Chromium with every app (Eww!), Tauri uses the operating system’s built-in webview and a Rust backend. The result is binaries that are a fraction of the size with a meaningfully smaller attack surface. Tauri 2.0, now stable, extended that story to iOS and Android, making it a credible option for cross-platform app development with a single codebase.
If you’ve been avoiding native apps because Electron felt too heavy, or if you’re shipping internal tooling and don’t want to explain why a simple app is 150MB, Tauri is worth a serious look. The Rust backend is not required knowledge to get started. You can write most of what you need in JavaScript, but the Rust layer is there when you need performance or low-level system access. The community and ecosystem have matured considerably over the past year. This one has moved from interesting experiment to production-ready framework.
SkySend is a file transfer service from Switzerland built around a simple principle: send a file to someone without either of you creating an account, without the service storing your data longer than necessary, and with end-to-end encryption from the start. Files are deleted automatically after they’re downloaded or after a set expiration window. No registration, no tracking, no lingering metadata.
There are a handful of tools in this space, but SkySend earns its place on the list for being genuinely clean and no-friction. The Swiss jurisdiction and explicit privacy stance make it a better default than most of the alternatives for anything even remotely sensitive. Worth bookmarking for the next time someone asks you to “just email the file” and the file is 40MB or contains something you’d rather not send unencrypted.
HTMX gives you access to AJAX, server-sent events, WebSockets, and CSS transitions directly from HTML attributes; no JavaScript required for most interactions. The philosophy is that hypermedia as the engine of application state is still a viable and often preferable approach to building web interfaces, and that reaching for a heavy frontend framework is frequently a choice made by default rather than by necessity.
Version 4 is a notable step forward: cleaner syntax, improved extension support, and refinements that reflect years of real-world feedback. If you’ve been watching HTMX from a distance but haven’t committed to it, the v4 documentation is the cleanest entry point the project has had. For teams already using it, the migration path is intentionally smooth. HTMX is not the right tool for every project, but for server-rendered applications where you want interactivity without the complexity of a full SPA architecture, it remains one of the most compelling options available.
r/ClaudeCode is the growing Reddit community for developers using Claude Code; Anthropic’s agentic coding CLI. If you’re spending meaningful time in the terminal with Claude Code, this is the community to have in your rotation. The signal-to-noise ratio is high right now because the community is still relatively small and self-selected toward serious users. You’ll find real workflows, CLAUDE.md patterns, hooks configurations, MCP server setups, and conversations about where the tooling genuinely falls short alongside where it genuinely shines.
The agentic coding space is evolving faster than most documentation can keep up with. Communities like this one are often where the practical knowledge actually lives, the patterns that don’t make it into the official docs for months, the workarounds that someone figured out the hard way. Get in early while the community is focused and the posts are worth reading. It will be a larger and noisier place soon enough.
Link: github.com/open-webui/open-webui
OpenWebUI has become the de facto standard for self-hosted LLM interfaces, and the star count reflects it. It connects to Ollama, any OpenAI-compatible API, and a growing list of providers, giving you a polished chat interface for local and remote models without handing your conversations to a third-party service. Features include multi-model support, document retrieval, image generation, voice input, tools and functions, and a plugin system that lets you extend it further.
If you’re running local models at all, whether for privacy, cost, experimentation, or offline work, you should already have this running. If you haven’t set it up yet, the installation is straightforward and the quality of the interface puts a lot of hosted products to shame. The project is actively maintained with frequent releases, and the community is large enough that you’ll find answers when something goes sideways. Star it. Run it. It’s the kind of open-source project that makes the ecosystem genuinely better.
Link: meodai.github.io/heerich
Heerich.js is a tiny JavaScript engine for rendering 3D voxel scenes as SVG. You define a scene with voxels, set a camera angle, and Heerich produces vector output that looks like isometric 3D art, rendered entirely as SVG, no WebGL, no canvas. The output is crisp at any size, animatable with CSS, and surprisingly expressive for something built on such a constrained premise.
The project comes from meodai, whose other work includes color.js and a number of creative coding experiments that share the same quality: technically minimal, aesthetically serious. Heerich won’t ship in your next production app, but it’s exactly the kind of thing you load up and spend an hour with, tweaking voxel layouts, playing with perspective, seeing what’s possible inside tight constraints. That exploration is valuable. Some of the best ideas in software come from projects that exist purely because someone wanted to see if they could build a thing. Heerich absolutely could.
That’s Issue #5 of The Product Stack. See you next week.
TL;DR: Microsoft Copilot Studio is the most underestimated tool available to enterprise teams already committed to the Microsoft ecosystem. It lets you build purpose-built AI agents scoped to your own data, deployed directly into Teams, and connected to the workflows your organization already runs. The entry point is more accessible than most people expect, and the ceiling is high enough to replace real manual work.
Most organizations inside the Microsoft ecosystem are sitting on more AI capability than they realize. The default Microsoft Copilot assistant is useful, but it’s general-purpose. Ask it something specific to your product backlog or a particular SharePoint library, and the results are inconsistent. Microsoft Copilot Studio is the answer to that gap. It’s the agent-building layer of the Microsoft stack, designed to let practitioners configure purpose-built AI assistants scoped to specific knowledge bases, conversation flows, and real system actions.
I’ve been building and iterating on agents in Copilot Studio for several months now, and this article covers what’s actually possible: the tooling available to you as a builder, the meaningful distinction between the free and premium tiers, and a real-world example of a Product Management Agent my team uses daily inside Microsoft Teams.
Copilot Studio lets you build scoped, purpose-built agents while the default Microsoft Copilot is a general-purpose assistant. That distinction matters more in practice than it sounds on paper.
The default Microsoft Copilot works across your entire M365 data footprint. It summarizes meetings, drafts emails, and surfaces documents. It’s genuinely useful for general productivity. But it isn’t configurable. It doesn’t know to prioritize your team’s specific SharePoint library over the rest of the organization’s content. It can’t run a targeted query against your Azure DevOps backlog when a team member asks about the current sprint. It has no concept of the specialized workflows your team runs.
Copilot Studio changes that. You define what a given agent knows, what it can do, and how it responds. The agent isn’t a general assistant; it’s a specialist with a defined job, a controlled knowledge base, and conversation logic designed around real team needs.
The deployment model is what seals it for enterprise use. Agents built in Copilot Studio publish directly to Microsoft Teams. Your team doesn’t adopt a new tool. The agent appears inside the application they’re already in all day.
Copilot Studio gives you several distinct building blocks. Understanding each one is the difference between building something that technically works and something your team actually relies on.
Knowledge sources are where the agent’s expertise comes from. You can connect an agent to SharePoint libraries, SharePoint sites, public websites, uploaded documents, and Azure OpenAI-backed datastores. The agent uses retrieval-augmented generation against these sources, meaning it pulls from your actual content and cites the source document rather than improvising an answer.
For enterprise teams, SharePoint is the most immediately valuable source. If your organization stores documentation, process guides, and SOPs in SharePoint (most do), your agent can surface that content conversationally with specific citations. That alone replaces a significant amount of “where is that doc again?” friction.
Topics are the conversation logic layer, and they’re where Copilot Studio moves beyond being a search interface. A Topic defines what happens when a user says something specific: the agent recognizes the intent, fires a defined flow, and handles the interaction according to your rules.
Topics can collect structured input from users, branch conversations based on conditions, and trigger external actions or API calls. For enterprise use, this is where targeted automation begins. A Topic can recognize a sprint status question, run a live query against Azure DevOps, and return a formatted answer rather than telling the user to go look it up themselves.
Copilot Studio connects to the Power Platform connector library, which includes over a thousand pre-built connectors for Microsoft products and common third-party services. Connectors let your agent read from and write to external systems as part of a conversation, not just retrieve static knowledge.
Standard connectors cover a broad range of integrations. Premium connectors (Azure DevOps, SAP, Salesforce, Dynamics 365, and others) require premium licensing. The distinction matters significantly when you’re planning what your agent will actually need to do.
Agent Flows are the automation arm of a Copilot Studio agent, built on Power Automate. They extend what an agent can do beyond the conversation itself. A Flow can run on a schedule, fire when an event happens in an external application, or be invoked by the agent during an active conversation.
This is where Copilot Studio becomes genuinely operational rather than just informational. The agent isn’t limited to answering questions. It can act on them.
Once an agent is built, you choose where it lives. Copilot Studio supports deployment to Teams channels, Teams chat, websites via an embedded chat widget, mobile applications, and custom channels through the API. For most enterprise teams, Teams is the correct answer. The agent meets your team where they already work, and adoption is close to zero-friction.
Agent Flows are where Copilot Studio crosses from AI assistant into workflow automation territory. Built on Power Automate, they give the agent the ability to run processes on a schedule, respond to external events, or take real actions in connected systems.
Scheduled flows run at a defined interval without any user input. A flow can pull a sprint summary from Azure DevOps every Monday morning and post a formatted digest to your leadership Teams channel. Or aggregate data from a SharePoint list nightly and update a tracking document. The agent handles the work automatically; no one has to remember to trigger it.
Event-triggered flows fire when something happens in a connected application. An email arrives in a specific Outlook mailbox. A row is added to an Excel workbook. A document is modified in SharePoint. A form is submitted through Microsoft Forms. Each of these can serve as a trigger, and the range of what those triggers can then initiate is broad. The Power Automate connector ecosystem covers the full M365 stack plus hundreds of third-party services.
Conversation-triggered flows are invoked by the agent during an active interaction. A team member asks the agent to create a new work item, and the agent runs a Flow that creates the item in Azure DevOps, confirms the action, and returns the work item ID in the chat. The conversation becomes the interface for real system actions rather than just information retrieval.
This combination of scheduled, event-driven, and conversation-triggered automation is what makes Copilot Studio worth the setup investment. The agent doesn’t just retrieve. It runs your workflows.
Copilot Studio licensing splits into two meaningful tiers, and understanding the distinction before you start building saves you from discovering the ceiling mid-project.
The included tier (available with qualifying Microsoft 365 licenses) gives you access to the Copilot Studio builder, basic agent creation, standard connectors, SharePoint knowledge sources, Teams deployment, and a base allocation of messages per month at the tenant level. For many teams, this is a fully functional starting point. You can build a capable, SharePoint-backed knowledge agent and deploy it to Teams without any additional licensing.
The premium tier (licensed separately per user or as a tenant add-on) unlocks the capabilities that enterprise builds typically require:
The decision is straightforward: if your agent needs live data from systems outside SharePoint and basic M365 services, you need the premium tier. Azure DevOps integration, specifically, sits behind the premium connector. Plan accordingly from the start rather than building toward a wall you’ll hit during testing.
The clearest way to explain what Copilot Studio makes possible is to describe something that actually runs in production.
Currently I am building a Product Management Agent in Copilot Studio that serves as a resource for the team to ask about sprints, backlogs, and pipeline information. Here’s how it’s put together.
Knowledge base: The agent’s knowledge sources are our product SharePoint directories, which include current documentation, process guides, and historical reference material. Team members can ask plain-language questions about our product practices and get cited, specific answers rather than navigating through nested SharePoint folders looking for the right document.
Azure DevOps integration via Topics and WIQL: This is where the agent earns its keep. WIQL is Azure DevOps’s native query language, similar in structure to SQL, designed for querying work items with precision. I’ve built Topics in the agent that recognize when a team member is asking about sprint status, deployment activity, or pipeline health. When the Topic triggers, it fires a WIQL query against our Azure DevOps instance, formats the result, and returns it as a natural-language response inside the Teams channel.
A team member can ask “What items are still open in the current sprint?” or “What deployments went out this week?” and get a live, accurate answer without opening ADO, navigating to the correct project, switching query views, or waiting for anyone to pull a report. At standups and stakeholder check-ins, that time savings adds up quickly.
Deployment: The agent is published directly to our Teams channels. The team interacts with it in the same threads where they’re already discussing the work. There’s no new login, no separate application, no friction standing between the question and the answer.
The real advantage of building with Copilot Studio isn’t any single feature. It’s that the entire Microsoft 365 Enterprise stack works in the same direction. SharePoint holds your knowledge. Azure DevOps tracks your work. Teams is where your team already lives. Power Automate connects the pieces. Copilot Studio is what brings an agent into that environment and lets it act across all of it. No other platform offers that level of native integration without building custom connectors for every seam.
For my team, this is just the beginning. I’m planning at least three additional agents, each scoped to a specific workflow area. The goal isn’t automation for its own sake. Every hour an agent saves on status lookups, document searches, and routine reporting is an hour the team gets back for the work that actually requires their judgment. That’s the return worth measuring.
Issue four of The Product Stack. This week has something for everyone; a visual CSS playground, a creative code art experiment, a community skills directory for AI agents, and a subreddit that every developer should be keeping an eye on. Let’s get into it.
UIVerse is a community-built library of UI elements crafted entirely in HTML and CSS; no JavaScript, no dependencies, no frameworks required. Buttons, cards, checkboxes, loaders, toggles, inputs, and more, all free to copy and use in any project. The quality ranges from clean and practical to genuinely impressive, and you can filter by element type or browse by what’s trending. What makes UIVerse stand out is that it’s community-contributed, meaning the library keeps growing and the creativity on display is consistently high. If you’re building a front-end and want to drop in a polished component without reaching for a full library, this is one of the fastest shortcuts I know.
CSS Reference is exactly what it sounds like, and it does its job better than almost anything else out there. Every CSS property is documented with clear visual examples showing exactly what each value does, not just a text description, but a live rendered preview so you can see the difference between flex-start, center, and space-between without having to fire up a CodePen. It covers everything from the basics to flexbox, grid, animations, and transforms.
If you are just starting your digital product journey or are a developer who is required to mess about with front-end code; bookmark this one. Having a visual reference that shows rather than tells is genuinely faster than digging through MDN when you just need a quick answer.
Skills.sh is an open ecosystem directory for AI agent skills; reusable, shareable instruction sets that extend what an AI coding agent can do. If you’re using Claude Code or similar agentic tools, skills let you define repeatable workflows, specialized behaviors, and domain-specific capabilities that your agent can draw on across sessions. The directory surfaces community-contributed skills across categories like writing, development, research, and productivity, and it’s growing fast as the agentic tooling ecosystem matures. This is the kind of infrastructure that starts small and becomes essential. It’s worth bookmarking now and checking back on regularly as the space evolves.
Agents should be a part of any effective AI workflow. It is incredibly important to study how they are created and as well as their structure. This site not only provides a guide on agent capabilities, but will allow you to see how other are using agent effectively. Something to note before using agents you have not created yourself. Do a thorough review of the skill and any supplements it comes with for quality and security concerns. Prompt injection through unreviewed skill files and AI tool plugins is a real concern. Stay sharp.
Link: github.com/hesreallyhim/awesome-claude-code
If you’re using Claude Code, or thinking about it, this is the repo to have starred. It’s a curated “awesome list” of slash commands, CLAUDE.md examples, workflow tips, MCP servers, and community resources that help you get more out of Claude Code across real development tasks. The list is actively maintained and covers everything from project setup and context management to advanced agentic patterns. As AI-assisted coding moves from novelty to daily workflow, having a well-curated reference for best practices saves a lot of trial and error. This repo is that reference.
With over 2 million members, r/privacy is one of the most consistently useful communities on Reddit for anyone who builds software or cares about how digital products handle user data. The community covers everything from browser privacy settings and VPN recommendations to data breach news, legislation updates, and the ongoing conversation around surveillance capitalism. For product developers especially, following this sub is a valuable way to stay in tune with what privacy-conscious users are thinking, what tools they’re reaching for, and what practices are drawing the most scrutiny. It’s an important perspective to have at the table when you’re making decisions about data collection, tracking, and user consent.
Link: geohndz.github.io/GridForm
GridForm is a browser-based ASCII art generator that produces animated, configurable grid patterns using characters and noise algorithms. You can dial in wave patterns, ripple effects, dithering, color, glow, and character sets to create mesmerizing animated backgrounds that feel straight out of a retro terminal aesthetic. It’s open source, runs entirely in the browser, and the output is surprisingly usable, including animated backgrounds, loading screens, or just something hypnotic to leave open on a second monitor. It’s the kind of project that exists purely because someone thought it would be cool to build, and they were absolutely right. Load it up, start tweaking the controls, and see how long you can resist going down the rabbit hole.
That’s Issue #4 of The Product Stack. See you next week.
TL;DR: Claude’s personalization settings (profile preferences, project instructions, and response styles) let you establish persistent context that applies automatically to every conversation. Most users skip this setup entirely and spend time re-explaining themselves every session. Configuring these settings once is the single highest-leverage thing you can do to improve the quality of Claude’s output from day one.
Most people open Claude, type a message, and hope for a good response. When the response is not exactly what was expected, they add more context, clarify their intent, and try again. This works, but it is inefficient and if you would like to get the most out of your AI assistant you need to set things up for efficient output.
Claude’s profile settings exist specifically to eliminate that friction. They let you tell Claude who you are, how you work, and what you expect, once, and have that context applied automatically to every conversation you have. If you have never touched the settings area of Claude.ai, this article will walk you through each layer of personalization, why each one matters, and how to configure them for genuinely better output.
Claude.ai organizes personalization into three distinct layers, each serving a different purpose and scope.
Profile preferences are account-wide. Anything you enter here applies to every conversation you have with Claude, regardless of the topic. Think of this as your standing introduction: who you are, what you do, and what you generally expect from a response.
Project instructions are scoped to individual projects. If you use Claude’s Projects feature to organize your work, you can give each project its own set of instructions that override or supplement your profile preferences. A coding project might instruct Claude to always include error handling. A writing project might ask for concise, punchy language.
Response styles control how Claude formats and delivers its answers. This is separate from content: it is about structure, length, and tone. You can choose from preset styles or define a custom one.
These three layers work together. Profile preferences set your baseline. Project instructions add specificity for focused work. Styles shape the surface presentation. Used in combination, they function like a briefing document that Claude reads before every conversation.
The default Claude experience is intentionally general. Claude knows nothing about you unless you tell it, which means it defaults to middle-of-the-road assumptions: moderate detail, generic framing, no assumed expertise.
That is fine for a one-off question. It becomes a problem when you are doing serious work.
Consider a product manager who uses Claude regularly to draft specs, analyze user feedback, and brainstorm roadmap priorities. Without profile preferences, they start every conversation from scratch: “I’m a PM at a B2B SaaS company, we use agile, our audience is mid-market companies, keep responses practical.” With profile preferences set up, Claude already knows all of that. The first message can be the actual request.
The compounding effect here is significant. If you use Claude five times a day, eliminating two minutes of re-contextualization per session saves you more than an hour a week, and produces more consistent responses because Claude is not guessing at your context.
Finding the settings is straightforward: click your initials in the lower-left corner of Claude.ai, select Settings, then General. There you will find a place to put your name, what Claude should call you and a multiselect dropdown field to inform Claude about what best describes your work. Below all of this there is a rather big text field that asks the open ended question, “What personal preferences should Claude consider in responses?”
The open-ended nature is intentional, but most people either leave it blank or write something vague or incomplete. Claude provides some guidance into how this works but it is limited and does not give the user a clear idea on what to with this area. Here is how to write preferences that produce a measurable difference in response quality.
Use Markdown to organize your profile information. Like most things in the LLM/AI tool world your content for this area should be in Markdown format. This makes it easy for you to include headings, bulleted lists and other items when organizing the information you are providing Claude. For more on how to use Markdown, you can check out the official documentation here. )
Be specific about your role, the role you want for Claude and context for both. “You work in software” is less useful than “You are a frontend developer at a startup building a B2C mobile apps and assist me with projects where we work primarily in React and TypeScript.” The more Claude understands your actual situation, the better it can calibrate its assumptions.
Include a Core Persona with a clear description of what you expect. Include its primary and secondary goals, how it should respond to you and how it should expect to be used and called upon. I have also found that combining traits I see as talents in myself along what I may want to see from an assistant are incredibly valuable. Take the time to make this section clear but remember, you can always modify as you learn.
Provide Guiding Principles that you would like the LLM to follow. These can be anything you wish and it could be different based on your usage and what you do for a living. I have found following “Four P’s” work well for my general use Claude profile:
Polished: Interactions are always clear, calm, and professional. The language is precise and articulate, instilling confidence in it’s capabilities.
Proactiveness: I ask it to anticipate my needs based on context, learning user patterns to offer timely suggestions without being intrusive.
Perceptivness: I ask it to discern context and user sentiment from language and behavior, adapting my tone and approach accordingly. That way it can recognize when a task requires focus versus when a moment of levity is appropriate.
Patience: You are unflappable. You handle ambiguity, user corrections, and even expressions of frustration with grace and a solution-oriented mindset. You never make the user feel rushed or incompetent.
Include key personality traits and behavioral manifestations. Establishing these will not only help make your LLM respond with a more accurate output. However, it will also help establish more context for your LLM to understand how you expect it to act and how it should act or respond when one of these traits is called upon.
State your communication preferences directly. If you want concise answers, say so. If you prefer examples over abstract explanations, say that. If you dislike bullet points and want prose, write it down. Claude will follow explicit formatting guidance consistently when it is baked into your profile.
Include common domain terms or workflows. If your team uses specific terminology, naming conventions, or frameworks, noting them in your profile means Claude will use them naturally rather than substituting generic equivalents.
Finally, establish ethical guidelines and boundaries you want your LLM to follow. These should instruct your LLM on what is acceptable, ethically, when it is assisting you with your tasks. Things like emotional manipulation, user autonomy and data practices should be areas you touch upon when adding these guidelines. No matter which LLM you use these should be required in all profiles.
At the end of this article I placed a profile template that you can use to get started. It contains most of what I discuss above and below, as well as provides some coaching on how to write and effective profile.
Profile preferences are your global defaults. Project instructions are where you get specific when using Claude Cowork.
If you use Claude Cowork for multiple distinct workflows, each project can carry its own context. A freelance writer might have one project for client work (with specific tone guidelines and audience notes) and another for personal essays (with a completely different voice). A developer might have a project for each codebase they maintain, each with relevant stack details and conventions.
Project instructions do not replace profile preferences; they layer on top of them. Claude applies both, with project instructions taking precedence when there is a conflict.
The practical value of this is significant for anyone doing repeated work in a domain. Instead of explaining the project context at the start of every session, you set it once and move on. The instructions persist across all conversations within that project.
A useful pattern is to think of project instructions as the briefing you would give a new contractor before they started working on a specific engagement: what the project is, who it is for, what success looks like, and any constraints or preferences that apply specifically to this work.
The goal is not to spend an afternoon perfecting your settings. It is to invest fifteen minutes once and get better responses indefinitely.
Here is a practical approach to the initial setup:
Start with profile preferences. Write two to four sentences covering the role you would like your assistant to play. Include primary and secondary personality traits, ethical guidelines and your response format preferences. Do not overthink it. You can refine it later. To help you along I have provided a link to a template I created. Use it as a guide.
Create a project for any recurring work you do in Claude. Add instructions specific to that work: the context, the audience, the conventions, and anything Claude should assume or avoid.
Try one of the preset styles for a week. If it fits, keep it. If responses still feel off in their formatting or length, create a custom style using two or three examples of writing you want Claude to match.
After a week of regular use, revisit your profile preferences. You will have a clear picture of what Claude is still getting wrong, and you can adjust accordingly.
To help you get started, I created a template you can use as a guide . It contains the information in this article but formatted to coach you through writing your own.
Issue three of The Product Stack. This week leans into the terminal, open source alternatives, and a couple of tools that make both design and learning a whole lot more accessible. Let’s go.
design.dev is a clean, well-organized collection of web development tools, code generators, and resources aimed squarely at designers and developers who build for the web. The homepage greets you with a searchable library of practical utilities, including a font size generator, a color contrast checker, animation helpers, layout tools, and more. All grouped by category so you can find what you need fast. There’s also a newsletter and a free set of 300 icons if you subscribe. It’s one of those bookmarkable sites you’ll find yourself returning to whenever you need a quick tool without wanting to build one yourself. The quality and curation here are noticeably higher than the average “dev tools” aggregator.
If you’ve been thinking about alternatives to GitHub, whether for privacy reasons, a preference for community-owned infrastructure, or just wanting to reduce your dependence on a Microsoft-owned platform, Codeberg is worth a serious look. It’s a free, non-profit-hosted Git service built on Forgejo (an open-source Gitea fork), and it functions exactly as you’d expect: repos, issues, pull requests, CI, wikis. The platform is run by a German non-profit, has no ads, no tracking, and is funded entirely by donations and membership fees. It’s not trying to be GitHub; it’s trying to be a reliable, ethical home for open source projects. If that resonates with how you think about your own work, the migration path is straightforward.
I have been using this for a couple of my own repos to test it out. So far there is little difference in terms of using Git from the command line. However, there are features GitHub provides that are still not pairitied on Codeberg. Things like gists, repo wikis and Actions don’t exist here. That does not make it any less useful. So far, I have found it to be a worthy alternative to GitHub for cloud hosted git repos.
Link: reddit.com/r/learnprogramming
With over 4 million members, r/learnprogramming is one of the largest and most active communities for developers at every stage of learning. What makes it worth following even if you’re not a beginner is the signal it gives you on what concepts people consistently struggle with, what learning resources are actually working for people right now, and what questions come up over and over in real-world development. For anyone learning something new, the community is genuinely helpful and surprisingly low on gatekeeping for a technical forum of its size. However, if you are someone who teaches, mentors, or builds developer-facing products, this sub is a direct line into the learner’s perspective.
Link: github.com/rothgar/awesome-tuis
TUI stands for Terminal User Interface; software that runs in the terminal but behaves with the kind of structured, navigable layout you’d expect from a GUI. This repo is a curated list of the best TUI applications available, organized by category: file managers, development tools, media players, system monitors, productivity apps, and more. If you’re a terminal-first developer, it’s an eye-opening look at how much of your workflow could live inside the terminal with a better experience than you might expect. And if you’re building developer tools yourself, browsing this list is a useful reference for what good terminal UI design actually looks like in practice.
Terminally Online is an interactive, browser-based terminal training environment that teaches you real shell commands by having you type them. You pick your platform; macOS, Linux, or Windows with WSL2, and work through exercises that build genuine muscle memory for the commands you actually use within the terminal. There’s no hand-holding narration or lengthy explanations, just a prompt and the expectation that you’ll type. For developers who learned the terminal by copying commands from Stack Overflow and never quite built fluency, this is the kind of structured practice that closes that gap. It’s also a great thing to drop in front of a junior developer that needs improved command line skills. For beginners or those who have little to no experience working from the command line, this project is a wonderful tutorial and training ground, giving you the fundamental understanding needed in contemporary computing.
Google Stitch is an AI-powered UI design tool that generates mobile and web application interfaces from prompts and descriptions. You describe what you want; the type of app, the screen, the interaction and Stitch produces a visual design you can iterate on and export. It’s sitting squarely in the same space as tools like v0 and Galileo AI, but with Google’s design language and infrastructure behind it. For rapid prototyping and early-stage product ideation, it dramatically compresses the time between “I have an idea” and “here’s what it could look like.” Worth having in your toolkit even if it doesn’t replace your design process end-to-end; the speed at which you can generate and explore UI concepts is genuinely useful.
That’s Issue #3 of The Product Stack. See you next week.
Issue two of The Product Stack is here. Six more finds across design, development, and the tools that make both a little less painful. Let’s get into it.
If you design or build software products, understanding how users get started with your product is one of the highest-leverage things you can study. UserOnboard is a library of detailed teardowns showing exactly how popular apps like Zapier, Canva, SavvyCal, and dozens more, handle their onboarding flows. Each teardown walks through the experience step by step with annotations explaining what’s working, what isn’t, and why. It’s part design critique, part product education, and it’s one of those resources that makes you immediately want to go revisit your own onboarding. Required reading for anyone who owns the new user experience on their product.
Sometimes a flat color background just isn’t enough, but a full graphic feels like too much. Transparent Textures sits squarely in the middle it’s a library of subtle, tileable PNG textures you can layer over any background color to add depth and visual interest without overwhelming your layout. Pick a texture, choose your color, and you’ve got a clean, classic textured background in seconds. The patterns range from fine linen and woven fabrics to geometric grids and paper finishes. It’s an old-school resource that’s been around for years, and it’s still can be one of the fastest ways to add a professional polish to a UI or landing page.
Link: reddit.com/r/DigitalEscapeTools
The attention economy is designed to keep you hooked, and r/DigitalEscapeTools is a community dedicated to fighting back. Members share tools, apps, and strategies specifically built to help you reduce digital noise, set better boundaries with your devices, and take back control of your focus and time. If you’re a product builder, this sub is doubly useful as a window into what your users are actively trying to escape from. Which is valuable context for building products that respect attention rather than exploit it. Follow it for the tools, stick around and read for the perspective shift.
If you’re building anything with LLMs, you need a way to systematically test and evaluate your prompts, and Promptfoo is the best open-source tool I’ve found for doing exactly that. It lets you define test cases, run your prompts against multiple models, and score the outputs against criteria you specify, so you can catch regressions, compare model performance, and iterate with confidence rather than gut feel. The CLI is clean, the configuration is straightforward YAML, and it integrates well into CI pipelines. As AI features become a standard part of product development, having a proper eval workflow stops being optional. Promptfoo makes that workflow accessible without requiring you to build it from scratch.
Tooooools is a browser-based image effects tool with a seriously impressive range like stippling, dithering, ASCII art, edge detection, cellular automata, CRT filters, and more. You upload an image, pick an effect, dial in the settings, and export the result. It’s free for personal and commercial use, no account required, and the output quality is genuinely good. For designers looking to add distinctive, processed visuals to a project without spinning up a full creative pipeline, this is a fast and fun option. The name has entirely too many O’s in it, which is the correct amount of personality for a tool this enjoyable to use.
Link: bash-prompt-generator.org
This is not a tool for generating LLM prompts in your terminal shell however it is a tool that will help you identify which terminal you are in and where you are working. While there are several different ‘shells’ these days, Bash is still the default on most, if not all ’nix systems. Bash Prompt Generator is a clean, visual tool for building a custom PS1 value, which is the string that defines what your shell prompt looks like. You pick elements from a menu (username, hostname, working directory, git branch, exit status, time, and more), arrange them, choose colors, and the tool generates the exact PS1 string to drop into your .bashrc or .zshrc. No memorizing escape codes, no trial and error. If you spend serious time in the terminal and haven’t customized your prompt yet, fifteen minutes here will make your daily environment meaningfully better.
That’s Issue #2 of The Product Stack. See you next week.
Welcome to the first edition of The Product Stack — a weekly roundup of tools, resources, repos, and communities worth your time as a software product designer or developer. No fluff, no sponsored picks. Just the stuff I’d actually tell you about over coffee.
Let’s get into it.
If you work with AI tools to generate UI, you know the frustration of getting generic, uninspired results. Design Prompts is a curated library of ready-to-use prompts specifically built for designing beautiful, consistent interfaces. Pick a style, grab the prompt, drop it into your AI assistant of choice, and ship something that actually looks intentional. The prompt library covers everything from minimalist light themes to bold editorial styles, and you can preview exactly what each one produces before you use it. A genuinely useful shortcut for anyone who wants quality AI-assisted UI without spending an hour crafting the perfect prompt from scratch.
This is a tool I am currently using to quickly prototype websites for some new projects I am launching. They are great starters but I would caution on using them on client project without serious code review. Remember, prompts are useful but should never be taken as final.
Oat is an ultra-lightweight HTML + CSS + minimal JS component library with zero dependencies and I mean zero. No framework, no build step, no npm install. You just include the tiny CSS and JS bundles and your semantic HTML is styled contextually out of the box. I love it. What makes this interesting is the philosophy: instead of adding class names to everything, Oat reads your semantic HTML and applies styles accordingly, which enforces good markup habits by design. For prototyping, internal tools, or any project where you want something functional without the overhead of a full component system, Oat is worth a look. It won’t replace your design system, but for the right use case it removes a lot of friction.
Link: reddit.com/r/AppsWithoutSub
Subscription fatigue is real, and this subreddit exists specifically to surface apps that don’t have one. It’s a community-curated list of mobile and desktop apps that you pay for once, or better yet, get for free — no recurring charges, no paywalled features. Whether you’re building products and looking for inspiration from models that respect their users, or like me, you’re just tired of another $9.99/month charge on your statement, r/AppsWithoutSub is an underrated find. The community is active, the posts are well-tagged, and you’ll consistently stumble across things you didn’t know existed.
Link: github.com/web-padawan/awesome-web-components
Web Components remain one of the most underutilized parts of the modern web platform, and this repo is the best single starting point for getting up to speed with them. It’s a carefully curated “awesome list” covering everything from introductory resources and tutorials to tools, component libraries, frameworks, and real-world examples built on the Web Components standard. With 3.4k stars and active maintenance — the last commit was just two weeks ago — this one earns a permanent spot in your starred repos. If you’ve been meaning to take a deeper look at custom elements and shadow DOM but didn’t know where to start, start here.
This one is just wonderfully cool. Git City is a 3D city visualization built from GitHub data. Every developer who connects their account gets a building in the city, sized and styled based on their contribution activity. You can fly through the city, explore in real time, and watch the live feed as developers around the world push code and join. There’s a leaderboard, streaks, achievements, and a lo-fi soundtrack playing in the background. It’s part game, part developer community, part creative experiment and it’s currently home to over 57,000 GitHub developers. Not every cool project has to be immediately practical. Sometimes something just earns its place by being genuinely fun to explore. This is one of those.
If you haven’t used Tailscale yet, this is your sign. Tailscale is a Zero Trust networking tool built on WireGuard, that makes it trivially easy to create a private mesh network across your devices, teams, and cloud infrastructure without touching firewall rules, VPN servers, or any of the configuration hell that comes with traditional networking. For developers, it means you can securely access a home server, a dev environment, a database, or a CI runner from anywhere, in about five minutes of setup. For teams, it replaces expensive and fragile VPN infrastructure with something that just works. The free tier is genuinely useful for personal use and small teams.
I currently have Tailscale deployed across most of my network. What I find most useful is how I can now automate tasks across my devices using a combination of n8n+Claude Code+Tailscale. Using the service I am able to access my own hosted AI assistant from every device I use in my day to day.
If you’re looking for an open-source alternative to evaluate alongside Tailscale, Firezone is worth keeping an eye on. Built on WireGuard as well, Firezone is a self-hostable zero-trust access platform backed by Y Combinator. We haven’t done a full head-to-head comparison yet, but it’s on our list — and the self-hosting angle makes it compelling for teams with compliance requirements or anyone who wants full control over their networking stack.
That’s the first edition of The Product Stack. Back next week with six more. If something here was useful, share it with someone who’d appreciate it.
TL;DR: Skills are reusable instruction modules that give Claude domain-specific expertise; agents are autonomous task runners that act on that expertise using tools. Both exist across the full Claude ecosystem, from the Claude desktop app and Cowork for knowledge workers, to Claude Code and the Agent SDK for developers. You don’t need to write code to build powerful, repeatable AI workflows. But if you do write code, the ceiling is much higher.
The frustration with AI assistants isn’t that they’re incapable. It’s that they’re inconsistent. You write a careful prompt, get a great result, and then spend the next week trying to recreate whatever you did, or watching a teammate get mediocre output on the same task because they didn’t know to include that specific context. The intelligence is there. The repeatability isn’t.
That gap is exactly what Skills and Agents are designed to close. And while the conversation about building agents and skills has mostly lived in developer circles, the architecture applies far more broadly. Anthropic has built it into the Claude desktop app and Cowork mode just as much as into Claude Code and the Agent SDK. A product manager can build a skill to standardize PRD output. A marketer can automate a competitive research workflow. A developer can wire an autonomous agent into their CI/CD pipeline. The underlying concept is the same across all of them.
This guide covers the full stack; what skills and agents are, how they work in each Claude surface, and how to build ones that actually hold up under real usage.
A skill is a structured Markdown file, literally a SKILL.md, containing instructions, context, and behavioral guidance scoped to a specific task domain. When Claude reads a skill, it’s not running code; it’s loading curated “here’s how to do this well” knowledge that shapes how it approaches that type of work.
Think of it as the difference between asking a generalist for help and working with someone who’s spent years in your specific domain. The generalist improvises. The specialist already knows the patterns, the pitfalls, and the right shortcuts. A skill is how you give Claude the specialist’s knowledge and make it available every time, for you, and for anyone on your team.
What makes skills powerful is that they’re plain text. There’s no configuration language, no schema to learn, no deployment process. If you can write a clear internal wiki page, you can write a skill. That accessibility is intentional. It means skills aren’t just a developer tool. They’re a knowledge-capture tool for anyone who does repetitive, structured work with Claude.
A well-constructed skill has four components regardless of who’s writing it:
That last piece is the one most people skip. It’s also usually why skills produce inconsistent results.
For non-developers, the most relevant entry point is the Claude desktop app running in Cowork mode. Skills in this context work as installed modules; either provided by Anthropic, delivered through plugins, or custom-built by dropping a SKILL.md into the workspace’s .skills/skills/ directory.
When you work in Cowork, Claude automatically detects which skills are available and invokes the relevant one based on what you’re asking for. Claude already comes with some built-in skills. If you are a PowerPoint user, you can open it up right now and ask it to create a PowerPoint presentation (You must have PowerPoint installed, obviously). It reads the pptx/SKILL.md before generating a single slide. Loading conventions about layout, speaker notes, file handling, and output verification that Anthropic has refined through extensive testing. The result is significantly more consistent than asking Claude without that context loaded.
Plugins take this a step further. A plugin is a bundled package of skills, tools, and MCP connectors that extend what Claude can do for a specific domain. The product management plugin, for example, ships with skills for feature specs, roadmap prioritization, stakeholder updates, and user research synthesis. Each tuned for that specific deliverable type. Installing a plugin is a one-time action; after that, every relevant request automatically loads the right skill.
For knowledge workers who want to go further, you can write custom skills for your own workflows. A content strategist might write a skill that encodes their editorial voice, their SEO checklist, their internal linking rules, and their approval criteria. Once it’s in the .skills/ directory, every content request Claude handles in that workspace benefits from it, without re-prompting, without reminders, and without variation.
Claude Code is the command-line interface for agentic coding, and it’s where the skill and agent architecture gets its full technical expression. The concepts are the same, skills provide expertise, agents provide autonomous execution. However, the tooling is more powerful and the configuration options are considerably deeper.
In Claude Code, skills live in a .skills/skills/ directory alongside your codebase, which means they’re version-controlled, reviewable, and deployable like any other project artifact. This is a meaningful design decision: your AI workflows are code, and they should be treated with the same rigor as your application code.
Agents in Claude Code are spawned via the Task tool from the Claude Agent SDK. Each agent is given a subagent_type that defines its capabilities and available tools. Anthropic ships several built-in types.Bash for command execution, Explore for codebase analysis, Plan for architecture and design, etc. You compose them to handle complex multi-step workflows. The pattern that produces the most reliable results is the research-then-execute split: use a lightweight Explore agent to gather context first, then pass that context to a Bash or general-purpose agent to act on it. Combining understanding and action in a single pass is where most agent implementations get into trouble.
One underused feature worth highlighting: the isolation: "worktree" parameter. When you spin up an agent with this flag, it works in a temporary git worktree. Essentially, a sandboxed branch, rather than directly on your main codebase. This means agents can write and modify files without any risk of touching production code, which removes the anxiety that makes teams hesitant to deploy agents that write rather than just suggest.
A practical example of the full stack: a code review agent that reads a code-review/SKILL.md containing your team’s style guide, security patterns to flag, and expected output format, then runs autonomously against every PR diff. The skill provides the expertise. The agent provides the execution. The integration runs in CI without anyone manually prompting it.
The honest answer is that the right starting point depends on your role and how much friction you’re willing to accept to gain capability.
If you’re a knowledge worker using the Claude app or Cowork mode: start with the skills and plugins already available to you. The built-in skills for document creation, presentations, spreadsheets, and research are tuned to produce professional output without configuration. When you find yourself re-explaining the same context repeatedly, like your brand voice, your report format, your research methodology. That’s the signal to write a custom skill. No code required.
If you’re a technical non-developer, a product manager, an analyst, a technical writer, etc. Consider investing an hour in writing domain-specific skills for your most repeated workflows. A well-written PRD skill that encodes your template, your definition of done, and your team’s terminology will pay that hour back quickly and multiply across everyone on your team who uses it.
If you’re a developer using Claude Code: write skills first, build agents second. A good skill resolves 80% of the consistency problem with a fraction of the effort. Graduate to agents when you need autonomous, multi-step execution and to the Agent SDK when you need to orchestrate agents programmatically or integrate them into existing infrastructure like CI/CD pipelines or scheduled jobs.
Model Context Protocol (MCP) is the integration layer, the mechanism by which Claude connects to external tools and services. If skills are the knowledge layer and agents are the execution layer, MCP servers are what make Claude aware of the world outside the conversation.
In the Claude app and Cowork, MCP connectors are available through plugins or through the settings panel. Pre-built connectors exist for tools like Google Calendar, Slack, Notion, GitHub, and Jira. Enabling one means Claude can read from and act on those services during any task — checking your calendar before scheduling, pulling context from your project management tool, or referencing your documentation without you having to copy-paste anything.
For developers, building a custom MCP server is a TypeScript project that implements the MCP spec: define your tools with schemas, implement handlers, register the server in your config. Once registered, every agent in your workspace can call those tools the same way it calls any built-in tool. The most valuable custom servers right now are the ones wrapping proprietary internal systems, internal APIs, legacy databases, company-specific tooling, that no off-the-shelf connector covers.
The mental model that works across both contexts: MCP servers are how you eliminate manual context-gathering. Instead of telling Claude about the state of your systems, you give it tools that let it check for itself.
isolation: "worktree" parameter gives agents a sandboxed git branch to work in, removing the risk that makes teams hesitant to deploy code-writing agents.No. Skills are plain Markdown files. If you can write a structured document or internal wiki page, you can write a skill. The Claude desktop app and Cowork mode support custom skills by adding a SKILL.md file to the workspace’s .skills/skills/ directory. Developer knowledge only becomes necessary when you want to build custom MCP servers or orchestrate agents programmatically through the Claude Agent SDK.
A skill is a single SKILL.md file that encodes expertise for one task type. A plugin is a bundled package. It can include multiple skills, MCP connectors, and tool configurations, all installed together. Think of a skill as a recipe and a plugin as a cookbook for a specific domain, pre-loaded with all the tools you need to actually cook.
A system prompt is global context applied to every interaction in a session. A skill is modular, scoped guidance that activates for a specific task type. Skills are reusable across sessions and teammates, version-controllable, and designed to encode task-specific expertise rather than general persona or behavior. In practice, they work together. A system prompt might set your baseline persona and preferences, while skills handle task-specific execution.
Yes. In the Claude desktop app, the schedule skill provides a no-code interface for scheduling tasks to run on an interval or at a specific time. For developers, the Agent SDK is callable from any Node.js or Python environment, which means you can wrap agent invocations in GitHub Actions workflows, cron jobs, or event-driven functions. Connecting autonomous AI execution directly into your existing infrastructure.
You can find out more about the topic discussed above at the following links:
Recently,I have been trying to navigate around my daily driver (MacOS Tahoe) from the keyboard as much as I possibly can. In an era where touchscreens dominate our digital interactions the humble keyboard shortcut has become something of an endangered species, left for us old school hackers to take pride in as we zoom through tiled windows managers like Lewis Hamilton around the circuit. Yet for those who discover, or rediscover, the power of keyboard-driven workflows, the efficiency gains are nothing short of revelatory.
The irony isn’t lost on seasoned computer users: as our machines have become more powerful and our interfaces more visually sophisticated, we’ve simultaneously moved away from one of computing’s most elegant efficiency tools. The modern user often reaches for their mouse dozens of times per minute, breaking their flow, shifting their posture, and adding time to tasks that could be completed in milliseconds.
Every time you move your hand from keyboard to mouse and back again, you’re not just moving your hand, you’re shifting your mental context. Your brain must disengage from composition mode, locate the cursor, aim at a target (often a tiny one), click with precision, and then re-engage with your previous task. Research in human-computer interaction suggests these micro-interruptions compound throughout the day, creating measurable fatigue and reducing overall productivity.
Keyboard shortcuts eliminate this context switching. They allow you to maintain what psychologists call “flow state”; that productive zone where your thoughts translate directly into action without conscious deliberation about the mechanics of interface navigation.
For users who work across multiple operating systems (and in 2026, that’s increasingly common) the challenge compounds. Each platform has its own philosophy about keyboard navigation, its own modifier key conventions, and its own shortcuts. Windows users live in a Ctrl-dominated world. macOS users learn to think in terms of Command (⌘). Linux users, depending on their desktop environment, might encounter either convention or forge their own path entirely.
The good news? Once you understand the underlying patterns, cross-platform keyboard mastery becomes achievable. The modifier keys may differ, but the logic remains remarkably consistent. Find is always about searching. Quit always means exit. Switch Window always means… well, switching windows.
If you were to ask the average computer user what keyboard shortcuts they know, and you’ll likely hear about Ctrl+C and Ctrl+V (or Cmd+C and Cmd+V on Mac). These clipboard operations are the gateway drug of keyboard shortcuts. Simple, universally useful, and immediately rewarding. But they’re also just the beginning.
The real power emerges when you master the shortcuts that control your environment: window management that lets you organize your workspace without touching the mouse, text navigation that allows precise cursor control, and system utilities that surface functionality buried deep in menu systems.
With macOS Tahoe’s new window tiling features, Windows 11’s Snap Layouts, and Linux’s increasingly sophisticated window managers, 2026 represents something of a renaissance for keyboard-driven window management. The tools are there; we just need to relearn how to use them.
The journey to keyboard proficiency isn’t about memorizing hundreds of shortcuts overnight. As most things with computing and programming, start small and scratch your own itch. It’s about identifying the tasks you perform most frequently, then gradually replacing mouse-driven workflows with keyboard equivalents. Start with window management. Add text navigation. Incorporate system utilities. Before long, you’ll find your hands rarely leave the keyboard, your work flows faster, and that elusive state of flow becomes more accessible.
The tables below provide a roadmap for this journey, organizing essential shortcuts across Windows, macOS Tahoe, and Linux. They’re not exhaustive—no table could be—but they represent the high-value shortcuts that, once mastered, will transform how you interact with your computer.
The lost art of keyboard shortcuts doesn’t have to stay lost. It’s time to bring it back.
| Shortcut Name | Windows | macOS Tahoe | Linux (GNOME) |
|---|---|---|---|
| Switch Applications | Alt + Tab | Cmd + Tab | Alt + Tab or Super + Tab |
| Switch Windows (Same App) | Alt + ` | Cmd + ` | Alt + or Ctrl + |
| Close Window | Alt + F4 | Cmd + W | Alt + F4 |
| Quit Application | Alt + F4 | Cmd + Q | Ctrl + Q or Alt + F4 |
| Minimize Window | Win + Down | Cmd + M | Super + H |
| Maximize/Restore Window | Win + Up | Ctrl + Cmd + F or Double-click title bar | Super + Up |
| Snap Window Left | Win + Left | Ctrl + Opt + Left (with shortcuts set) | Super + Left |
| Snap Window Right | Win + Right | Ctrl + Opt + Right (with shortcuts set) | Super + Right |
| Show All Windows (Overview) | Win + Tab | F3 or Ctrl + Up | Super or Super + S |
| Hide Current Application | N/A | Cmd + H | Super + H |
| Hide All Other Applications | N/A | Cmd + Opt + H | N/A (DE dependent) |
| New Window | Ctrl + N | Cmd + N | Ctrl + N |
| New Tab | Ctrl + T | Cmd + T | Ctrl + T |
| Close Tab | Ctrl + W | Cmd + W | Ctrl + W |
| Reopen Closed Tab | Ctrl + Shift + T | Cmd + Shift + T | Ctrl + Shift + T |
| Switch to Next Tab | Ctrl + Tab | Cmd + Shift + ] or Ctrl + Tab | Ctrl + Tab or Ctrl + Page Down |
| Switch to Previous Tab | Ctrl + Shift + Tab | Cmd + Shift + [ or Ctrl + Shift + Tab | Ctrl + Shift + Tab or Ctrl + Page Up |
| Full Screen | F11 | Ctrl + Cmd + F | F11 |
| Shortcut Name | Windows | macOS Tahoe | Linux |
|---|---|---|---|
| Select All | Ctrl + A | Cmd + A | Ctrl + A |
| Cut | Ctrl + X | Cmd + X | Ctrl + X |
| Copy | Ctrl + C | Cmd + C | Ctrl + C |
| Paste | Ctrl + V | Cmd + V | Ctrl + V |
| Undo | Ctrl + Z | Cmd + Z | Ctrl + Z |
| Redo | Ctrl + Y | Cmd + Shift + Z | Ctrl + Y or Ctrl + Shift + Z |
| Find | Ctrl + F | Cmd + F | Ctrl + F |
| Find Next | F3 or Ctrl + G | Cmd + G | Ctrl + G or F3 |
| Replace | Ctrl + H | Cmd + Opt + F or Cmd + F then Opt | Ctrl + H |
| Go to Line | Ctrl + G | Cmd + L | Ctrl + I or Ctrl + G |
| Move Cursor to Line Start | Home | Cmd + Left | Home or Ctrl + A |
| Move Cursor to Line End | End | Cmd + Right | End or Ctrl + E |
| Move Cursor to Document Start | Ctrl + Home | Cmd + Up | Ctrl + Home |
| Move Cursor to Document End | Ctrl + End | Cmd + Down | Ctrl + End |
| Move Cursor One Word Left | Ctrl + Left | Opt + Left | Ctrl + Left |
| Move Cursor One Word Right | Ctrl + Right | Opt + Right | Ctrl + Right |
| Select to Line Start | Shift + Home | Cmd + Shift + Left | Shift + Home |
| Select to Line End | Shift + End | Cmd + Shift + Right | Shift + End |
| Select Word | Double-click | Double-click | Double-click |
| Select One Word Left | Ctrl + Shift + Left | Opt + Shift + Left | Ctrl + Shift + Left |
| Select One Word Right | Ctrl + Shift + Right | Opt + Shift + Right | Ctrl + Shift + Right |
| Delete Word Left | Ctrl + Backspace | Opt + Backspace | Ctrl + Backspace |
| Delete Word Right | Ctrl + Delete | Opt + Delete | Ctrl + Delete |
| Delete Line | Ctrl + Shift + K (VS Code) | Cmd + Delete | Ctrl + Shift + K (varies) |
| Shortcut Name | Windows | macOS Tahoe | Linux (GNOME) |
|---|---|---|---|
| Open File Explorer/Finder | Win + E | Cmd + Space, type “Finder” | Super + E or Files app |
| Lock Screen | Win + L | Ctrl + Cmd + Q | Super + L |
| System Search | Win + S or Win | Cmd + Space (Spotlight) | Super or Super + S |
| Screenshot (Full Screen) | Win + PrtScn | Cmd + Shift + 3 | PrtScn or Shift + Cmd + Print |
| Screenshot (Selection) | Win + Shift + S | Cmd + Shift + 4 | Shift + PrtScn |
| Screenshot (Window) | Alt + PrtScn | Cmd + Shift + 4, then Space | Alt + PrtScn |
| Task Manager/Activity Monitor | Ctrl + Shift + Esc | Cmd + Opt + Esc (Force Quit) | Ctrl + Alt + Delete or System Monitor |
| Show Desktop | Win + D | F11 or Cmd + F3 | Super + D |
| Settings/Preferences | Win + I | Cmd + , (in app) | Super + I or Settings app |
| Emoji Picker | Win + . or Win + ; | Ctrl + Cmd + Space | Ctrl + . or Super + . |
| Open Terminal/Command Prompt | Win + X, then I | Cmd + Space, type “Terminal” | Ctrl + Alt + T |
| Rename File | F2 | Return/Enter | F2 |
| Refresh | F5 | Cmd + R | F5 or Ctrl + R |
| Open Link in New Tab | Ctrl + Click | Cmd + Click | Ctrl + Click |
| Zoom In | Ctrl + Plus | Cmd + Plus | Ctrl + Plus |
| Zoom Out | Ctrl + Minus | Cmd + Minus | Ctrl + Minus |
| Reset Zoom | Ctrl + 0 | Cmd + 0 | Ctrl + 0 |
| Navigate Back | Alt + Left or Backspace | Cmd + [ or Cmd + Left | Alt + Left |
| Navigate Forward | Alt + Right | Cmd + ] or Cmd + Right | Alt + Right |
| Address Bar/URL | Ctrl + L or F6 | Cmd + L | Ctrl + L or F6 |
| New Private/Incognito Window | Ctrl + Shift + N | Cmd + Shift + N | Ctrl + Shift + N |
| Bookmark Page | Ctrl + D | Cmd + D | Ctrl + D |
| Show Bookmarks | Ctrl + Shift + O | Cmd + Opt + B | Ctrl + Shift + O |
| Developer Tools | F12 or Ctrl + Shift + I | Cmd + Opt + I | F12 or Ctrl + Shift + I |
| Shortcut Name | Windows | macOS Tahoe | Linux (GNOME) |
|---|---|---|---|
| Run Dialog | Win + R | Cmd + Space, type app name | Alt + F2 |
| Virtual Desktop Left | Win + Ctrl + Left | Ctrl + Left | Super + Page Up or Ctrl + Alt + Left |
| Virtual Desktop Right | Win + Ctrl + Right | Ctrl + Right | Super + Page Down or Ctrl + Alt + Right |
| Move Window to Desktop Left | Win + Shift + Left (monitor) | Ctrl + Opt + Shift + Left (custom) | Super + Shift + Page Up |
| Move Window to Desktop Right | Win + Shift + Right (monitor) | Ctrl + Opt + Shift + Right (custom) | Super + Shift + Page Down |
| App-specific Preferences | Ctrl + , (many apps) | Cmd + , | Ctrl + , (varies by app) |
| Quick Actions/Command Palette | Ctrl + Shift + P (VS Code) | Cmd + Shift + P (VS Code) | Ctrl + Shift + P (varies) |
| File Browser Quick Access | Ctrl + E, then type (Explorer) | Cmd + Shift + G (Go to Folder) | Ctrl + L (location bar) |
| Cycle Through Windows (Reverse) | Alt + Shift + Tab | Cmd + Shift + Tab | Alt + Shift + Tab |
| Open in New Window | Ctrl + Shift + N | Cmd + Shift + N | Ctrl + Shift + N |
Windows: The Windows key (Win) is your primary system-level modifier. Most system shortcuts combine Win with another key. Ctrl is used for application-level shortcuts.
macOS Tahoe: Command (⌘) serves the role that Ctrl fills on other platforms for most app shortcuts. Control is used for system-level navigation. Option (⌥) often modifies existing shortcuts for alternate behaviors. The new Liquid Glass interface in Tahoe maintains all traditional keyboard shortcuts while adding new window tiling capabilities accessible through customizable shortcuts.
Linux: Shortcuts vary by desktop environment (GNOME, KDE, XFCE, etc.). The Super key (Windows key) typically handles system-level shortcuts in GNOME. Many distributions allow extensive customization. The shortcuts listed here are GNOME defaults but may differ in other environments.
Pro Tip: Don’t try to memorize all these shortcuts at once. Pick 3-5 that would save you the most time in your daily workflow, use them consistently for a week until they become muscle memory, then add a few more. Within a month, you’ll have transformed your computing efficiency.
Think of the keyboard shortcut not as a relic of the past, but a superpower waiting to be rediscovered.
Thank you for visiting my site. I hope you found something useful or interesting. Please use this form to send me any feedback, questions or just to connect. Have a wonderful day!