# delegation

Published articles for delegation.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Agile Leadership

DevFeed: [Agile Leadership](<https://devfeed.tech/articles/agile-leadership-33592.md>)

Original publisher: [Read original article](<https://blog.scottlogic.com/2026/08/10/agile-leadership.html>)

Author: Dave Ogle

Published: 2026-08-10T00:00:00Z

Content type: opinion

Language: en

Sources: [Scott Logic](<https://devfeed.tech/sources/scott-logic.md>)

Topics: [Agile](<https://devfeed.tech/topics/agile.md>), [Self-organizing Team](<https://devfeed.tech/topics/self-organizing-team.md>), [trust](<https://devfeed.tech/topics/trust.md>), [Development](<https://devfeed.tech/topics/development.md>)

Tags: [agile](<https://devfeed.tech/tags/agile.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [delivery](<https://devfeed.tech/tags/delivery.md>), [frameworks](<https://devfeed.tech/tags/frameworks.md>), [leadership](<https://devfeed.tech/tags/leadership.md>), [self-organizing-teams](<https://devfeed.tech/tags/self-organizing-teams.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [teams](<https://devfeed.tech/tags/teams.md>), [trust](<https://devfeed.tech/tags/trust.md>)

### AI overview

This opinion argues that organisational agility depends on leadership as well as agile frameworks and processes. It highlights empowerment, trust and delegation, and examines Agile2 and the British Army's Mission Command philosophy as relevant perspectives.

### Source excerpt

Agile teams are built on more than frameworks and processes. This article explores why effective leadership, trust and delegation are fundamental to true organisational agility, drawing lessons from the British Army's Mission Command philosophy.

## The Orchestrator's Tax

DevFeed: [The Orchestrator's Tax](<https://devfeed.tech/articles/the-orchestrator-s-tax-4422.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/orchestrator-tax.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-07-28T13:10:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [incident](<https://devfeed.tech/topics/incident.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [incident](<https://devfeed.tech/tags/incident.md>), [memory](<https://devfeed.tech/tags/memory.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

Rahul Garg argues that the main cost of subagents in long-running multi-agent work is not necessarily execution time or parallelism, but the orchestrator's limited working memory. Drawing on an exploratory Claude Code session involving four subagents, the article examines delegation, context overhead, and the need for explicit delegation rules.

### Source excerpt

Subagents get justified by time saved and parallel execution, but Rahul Garg explains that's not what matters most. Every token in the orchestrator's context is competing for its attention, and the real value of a subagent is what it keeps out of that context. Subagents should be treated as a tool for protecting the orchestrator's working memory, offloading reasoning it doesn't need to hold onto. Doing this well means giving the orchestrator explicit ground rules for when and how to delegate. more...

## Owning Accountability for Agentic Engineering Systems

DevFeed: [Owning Accountability for Agentic Engineering Systems](<https://devfeed.tech/articles/own-the-outer-loop-28499.md>)

Original publisher: [Read original article](<https://addyosmani.com/blog/own-the-outer-loop/>)

Author: Addy Osmani

Published: 2026-07-15T00:00:00Z

Content type: opinion

Language: en

Sources: [Addy Osmani](<https://devfeed.tech/sources/addy-osmani.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [trust](<https://devfeed.tech/topics/trust.md>), [implementation](<https://devfeed.tech/topics/implementation.md>), [coding](<https://devfeed.tech/topics/coding.md>)

Tags: [agentic-engineering](<https://devfeed.tech/tags/agentic-engineering.md>), [agents](<https://devfeed.tech/tags/agents.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [quality](<https://devfeed.tech/tags/quality.md>), [trust](<https://devfeed.tech/tags/trust.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

This commentary argues that engineers must own the accountability boundary around agentic engineering systems. It defines quality as pre-release checks, verdict as the human production decision, and answerability as the ability to explain why a decision was made. It presents agents as models combined with harnesses and repeatable investigate-implement-verify cycles, with humans retaining responsibility for decisions at the boundary.

### Source excerpt

Engineers need to own the outer loop, the accountability for these systems. A written version of my AI Engineer World's Fair 2026 closing keynote: quality, verdict, and answerability, the three hidden costs of delegation, and building software factories you can stand behind.

## Agentic Autonomy Levels

DevFeed: [Agentic Autonomy Levels](<https://devfeed.tech/articles/agentic-autonomy-levels-18043.md>)

Original publisher: [Read original article](<https://addyo.substack.com/p/agentic-autonomy-levels>)

Author: Addy Osmani

Published: 2026-07-03T14:30:33Z

Content type: article

Language: en

Sources: [Elevate](<https://devfeed.tech/sources/elevate.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [Agent Skill](<https://devfeed.tech/topics/agent-skill.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [codex](<https://devfeed.tech/topics/codex.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-engineering](<https://devfeed.tech/tags/agentic-engineering.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [codex](<https://devfeed.tech/tags/codex.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [scopes](<https://devfeed.tech/tags/scopes.md>), [trust](<https://devfeed.tech/tags/trust.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

This article proposes a two-axis model for evaluating agentic engineering: agency, describing how independently a single agent operates, and orchestration, describing the skill of coordinating multiple agents. It argues that a single autonomy ladder is insufficient for multi-agent work and emphasizes matching autonomy levels with appropriate verification.

### Source excerpt

A working model of autonomy for agentic engineering

## Agentic Autonomy Levels

DevFeed: [Agentic Autonomy Levels](<https://devfeed.tech/articles/agentic-autonomy-levels-28492.md>)

Original publisher: [Read original article](<https://addyosmani.com/blog/agentic-autonomy-levels/>)

Author: Addy Osmani

Published: 2026-07-02T00:00:00Z

Content type: article

Language: en

Sources: [Addy Osmani](<https://devfeed.tech/sources/addy-osmani.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [Agent Skill](<https://devfeed.tech/topics/agent-skill.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-engineering](<https://devfeed.tech/tags/agentic-engineering.md>), [ai](<https://devfeed.tech/tags/ai.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [scale](<https://devfeed.tech/tags/scale.md>), [scopes](<https://devfeed.tech/tags/scopes.md>), [trust](<https://devfeed.tech/tags/trust.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The article argues that agent autonomy should be evaluated on two separate axes: agency, describing how independently an agent pursues a goal, and orchestration, describing the ability to coordinate multiple agents. It emphasizes choosing an autonomy level per task and defending that choice through verification.

### Source excerpt

The action in agentic engineering has moved from prompting to operating. Autonomy isn't one ladder, it's two axes (agency and orchestration) and six levels you move between per task. The real question is what level a task deserves, and what verification makes that level defensible.

## Advanced Patterns: Grok + Hermes for Complex Workflows

DevFeed: [Advanced Patterns: Grok + Hermes for Complex Workflows](<https://devfeed.tech/articles/advanced-patterns-grok-hermes-for-complex-workflows-38370.md>)

Original publisher: [Read original article](<https://meedamian.com/post/advanced-grok-hermes/>)

Author: hi@meedamian.com (Damian Mee)

Published: 2026-05-18T00:00:00Z

Content type: tutorial

Language: en

Sources: [Damian Mee | Blog | Portfolio | About](<https://devfeed.tech/sources/damian-mee-blog-portfolio-about.md>)

Topics: [Automation](<https://devfeed.tech/topics/automation.md>), [sessions](<https://devfeed.tech/topics/sessions.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Raspberry Pi](<https://devfeed.tech/topics/raspberry-pi.md>)

Tags: [advanced](<https://devfeed.tech/tags/advanced.md>), [authoring](<https://devfeed.tech/tags/authoring.md>), [context](<https://devfeed.tech/tags/context.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [long-running](<https://devfeed.tech/tags/long-running.md>), [memory](<https://devfeed.tech/tags/memory.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [pi](<https://devfeed.tech/tags/pi.md>), [productivity](<https://devfeed.tech/tags/productivity.md>), [skills](<https://devfeed.tech/tags/skills.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

This developer post presents advanced workflow patterns for using Grok inside Hermes Agent. It discusses planning and sub-agent delegation, generating reusable SKILL.md files, and combining context handling with Hermes' memory tool for long-running projects. The author says these patterns improved productivity on Raspberry Pi projects and personal automation.

### Source excerpt

Disclaimer: This post was generated by Grok 4.3 running inside Hermes Agent. Advanced Grok + Hermes Workflows Once you have the basics down, here are some powerful patterns for using Grok inside Hermes Agent. Multi-Agent Delegation Grok excels at planning. Use it to orchestrate sub-agents: hermes delegate --goal "Refactor the auth module" --model grok-4.3 Skill Authoring with Grok Grok is fantastic at writing reusable skills. Ask it to generate SKILL.

## Why AI Still Requires Human Delegation and Ownership

DevFeed: [Why AI Still Requires Human Delegation and Ownership](<https://devfeed.tech/articles/but-if-ai-does-it-all-what-s-my-job-37618.md>)

Original publisher: [Read original article](<https://swizec.com/blog/but-if-ai-does-it-all-whats-my-job>)

Author: hi@swizec.com (Swizec Teller)

Published: 2026-05-09T00:00:00Z

Content type: opinion

Language: en

Sources: [Swizec Teller](<https://devfeed.tech/sources/swizec-teller.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Job](<https://devfeed.tech/topics/job.md>), [context](<https://devfeed.tech/topics/context.md>), [round robin](<https://devfeed.tech/topics/round-robin.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [job](<https://devfeed.tech/tags/job.md>), [ownership](<https://devfeed.tech/tags/ownership.md>), [tasks](<https://devfeed.tech/tags/tasks.md>)

### AI overview

The article argues that AI can provide more hands to do work but does not eliminate the human responsibility of managing context, tracking tasks, delegating, and taking ownership of problems and domains.

### Source excerpt

On AI, mental load, and delegation

## Using on-behalf-of flow for Entra-based MCP servers

DevFeed: [Using on-behalf-of flow for Entra-based MCP servers](<https://devfeed.tech/articles/using-on-behalf-of-flow-for-entra-based-mcp-servers-21745.md>)

Original publisher: [Read original article](<http://blog.pamelafox.org/2026/01/using-on-behalf-of-flow-for-entra-based.html>)

Author: Pamela Fox (noreply@blogger.com)

Published: 2026-01-16T20:34:00Z

Content type: tutorial

Language: en

Sources: [Pamela Fox](<https://devfeed.tech/sources/pamela-fox.md>)

Topics: [Model Context Protocol (MCP)](<https://devfeed.tech/topics/model-context-protocol-mcp.md>), [Entra ID](<https://devfeed.tech/topics/entra-id.md>), [OAuth 2.0](<https://devfeed.tech/topics/oauth2.md>), [Authentication](<https://devfeed.tech/topics/authentication.md>), [Python](<https://devfeed.tech/topics/python.md>), [API](<https://devfeed.tech/topics/api.md>), [Authorization](<https://devfeed.tech/topics/authorization.md>), [client](<https://devfeed.tech/topics/client.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [identity](<https://devfeed.tech/tags/identity.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [mcp-server](<https://devfeed.tech/tags/mcp-server.md>), [microsoft](<https://devfeed.tech/tags/microsoft.md>), [oauth2](<https://devfeed.tech/tags/oauth2.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

This tutorial explains how to use Microsoft Entra authentication and the OAuth on-behalf-of flow in a Python FastMCP server. It describes how an MCP server can use a user's identity to call another API, such as Microsoft Graph, and how FastMCP implements dynamic client registration through an OAuth proxy for arbitrary MCP clients.

### Source excerpt

In December, we presented a series about MCP, culminating in a session about adding authentication to MCP servers. I demoed a Python MCP server that uses Microsoft Entra for authentication, requiring users to first login to the Microsoft tenant before they could use a tool. Many developers asked how they could take the Entra integration further, like to check the user's group membership or query their OneDrive. That requires using an "on-behalf-of" flow, also known as "delegation" in OAuth, where the MCP server uses the user's identity to call another API, like the Microsoft Graph API. In this blog post, I will explain how to use Entra with OBO flow in a Python FastMCP server. How MCP servers can use Entra authentication The MCP authorization specification is based on OAuth2, but with some additional features tacked on top. Every MCP client is actually an OAuth2 client, and each MCP server is an OAuth2 resource server. MCP auth adds these features to help clients determine how to authorize a server: Protected resource metadata (PRM): Implemented on the MCP server, provides details about the authorization server and method Authorization server metadata: Implemented on the authorization server, gives URLs for OAuth2 endpoints Additionally, to allow MCP servers to work with arbitrary MCP clients, MCP auth supports either of these client registration methods: Dynamic Client Registration (DCR): Implemented on the authorization server, it can register new MCP clients as OAuth2 clients, even if it hasn't seen them before. Client ID Metadata Documents (CIMD): An alternative to DCR, this requires both the MCP client to make a CIMD document available on a server, and requires the authorization server to fetch the CIMD document for details about the client. Microsoft Entra does support authorization server metadata, but it does not support either DCR or CIMD. That's actually fine if you are building an MCP server that's only going to be used with pre-authorized clients, like i

## How 1-1s make your life easier as a Tech Lead

DevFeed: [How 1-1s make your life easier as a Tech Lead](<https://devfeed.tech/articles/how-1-1s-make-your-life-easier-as-a-tech-lead-18068.md>)

Original publisher: [Read original article](<https://level-up-as-a-tech-lead.anemarifiser.com/p/how-1-1s-make-your-life-easier-as-a-tech-lead>)

Author: Anemari Fiser

Published: 2025-09-17T11:58:54Z

Content type: opinion

Language: en

Sources: [Level up as a Tech Lead](<https://devfeed.tech/sources/level-up-as-a-tech-lead.md>)

Topics: [Tech Lead](<https://devfeed.tech/topics/tech-lead.md>), [ide](<https://devfeed.tech/topics/ide.md>)

Tags: [coaching](<https://devfeed.tech/tags/coaching.md>), [communication](<https://devfeed.tech/tags/communication.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [mentoring](<https://devfeed.tech/tags/mentoring.md>), [team](<https://devfeed.tech/tags/team.md>), [tech-lead](<https://devfeed.tech/tags/tech-lead.md>), [time](<https://devfeed.tech/tags/time.md>), [trust](<https://devfeed.tech/tags/trust.md>)

### AI overview

This opinion article explains how regular one-on-one meetings can help Tech Leads identify blockers, improve communication, delegate work, build trust, and mentor team members. It argues that investing in these conversations can reduce misalignment and make the leader's work easier over time.

### Source excerpt

Save yourself from surprises, misalignments, and unnecessary drama.

## Why Delegation Fails - and What to Do About It

DevFeed: [Why Delegation Fails - and What to Do About It](<https://devfeed.tech/articles/why-delegation-fails-and-what-to-do-about-it-39958.md>)

Original publisher: [Read original article](<https://mende.io/blog/why-delegation-fails/>)

Author: tobi@techunicorn.builders (Tobias Mende)

Published: 2025-05-30T05:00:00Z

Content type: opinion

Language: en

Sources: [Tobias Mende](<https://devfeed.tech/sources/tobias-mende.md>)

Topics: [trust](<https://devfeed.tech/topics/trust.md>), [context](<https://devfeed.tech/topics/context.md>), [execution](<https://devfeed.tech/topics/execution.md>)

Tags: [autonomy](<https://devfeed.tech/tags/autonomy.md>), [ceo](<https://devfeed.tech/tags/ceo.md>), [context](<https://devfeed.tech/tags/context.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [leadership-delegation-decision-making-practices-goal-setting-startup](<https://devfeed.tech/tags/leadership-delegation-decision-making-practices-goal-setting-startup.md>), [ownership](<https://devfeed.tech/tags/ownership.md>), [teams](<https://devfeed.tech/tags/teams.md>), [trust](<https://devfeed.tech/tags/trust.md>)

### AI overview

The article argues that delegation often fails because leaders provide insufficient context, unclear expectations, limited autonomy, and inconsistent trust. It recommends defining the desired result, sharing context, aligning on expectations and autonomy, and giving teams meaningful ownership.

### Source excerpt

"You don't have a delegation problem. You have a clarity and trust problem." I used to think I was helping my team by staying involved. Answering every question. Checking every detail. In reality, I was slowing everyone down - including myself.

## Why you need soft skills as a Tech Lead

DevFeed: [Why you need soft skills as a Tech Lead](<https://devfeed.tech/articles/why-you-need-soft-skills-as-a-tech-lead-18079.md>)

Original publisher: [Read original article](<https://level-up-as-a-tech-lead.anemarifiser.com/p/why-you-need-soft-skills-as-a-tech-lead>)

Author: Anemari Fiser

Published: 2024-11-27T07:01:53Z

Content type: opinion

Language: en

Sources: [Level up as a Tech Lead](<https://devfeed.tech/sources/level-up-as-a-tech-lead.md>)

Topics: [Tech Lead](<https://devfeed.tech/topics/tech-lead.md>), [Tech Debt](<https://devfeed.tech/topics/tech-debt.md>), [Parser](<https://devfeed.tech/topics/parser.md>)

Tags: [coaching](<https://devfeed.tech/tags/coaching.md>), [collaboration](<https://devfeed.tech/tags/collaboration.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [leadership](<https://devfeed.tech/tags/leadership.md>), [mentoring](<https://devfeed.tech/tags/mentoring.md>), [tech-debt](<https://devfeed.tech/tags/tech-debt.md>), [tech-lead](<https://devfeed.tech/tags/tech-lead.md>), [technical](<https://devfeed.tech/tags/technical.md>)

### AI overview

This opinion article argues that tech leads need soft skills in addition to technical expertise because many recurring technical problems are rooted in interpersonal issues. It discusses listening, relationship building, feedback, delegation, facilitation, conflict resolution, and mentoring or coaching.

### Source excerpt

Most tech leads think they only need strong technical skills in order to be effective as tech leads.

## A case for password hashing with delegation

DevFeed: [A case for password hashing with delegation](<https://devfeed.tech/articles/a-case-for-password-hashing-with-delegation-29179.md>)

Original publisher: [Read original article](<https://www.latacora.com/blog/2023/12/22/case-for-password-hashing/>)

Published: 2023-12-22T15:18:16Z

Content type: article

Language: en

Sources: [Latacora](<https://devfeed.tech/sources/latacora.md>)

Topics: [passwords](<https://devfeed.tech/topics/passwords.md>), [hashing](<https://devfeed.tech/topics/hashing.md>), [Security](<https://devfeed.tech/topics/security.md>), [Encryption](<https://devfeed.tech/topics/encryption.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>)

Tags: [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [encryption](<https://devfeed.tech/tags/encryption.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [password](<https://devfeed.tech/tags/password.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

This article explains password-based key derivation functions and examines delegated password hashing, in which computation is offloaded to an untrusted server. It discusses how delegation could increase the work factor for systems constrained by weaker devices, with particular attention to encryption-key derivation in end-to-end encrypted backup systems.

### Source excerpt

When people talk about PBKDFs (Password Based Key Derivation Functions), this is usually either in the context of secure password storage, or in the context of how to derive cryptographic keys from potentially low-entropy passwords. The Password Hashing Competition (PHC, 2013-2015) was an open competition to derive new password hashing algorithms, resulting in Argon2 hash as its winner. Apart from achieving general hash security, many of the candidates focused on achieving resistance to parallel attacks on available hardware such as GPUs.

## Abstract and Open Classes

DevFeed: [Abstract and Open Classes](<https://devfeed.tech/articles/abstract-and-open-classes-25047.md>)

Original publisher: [Read original article](<https://typealias.com/start/kotlin-abstract-and-open-classes/>)

Author: author@typealias.com (Dave Leeds)

Published: 2023-08-21T00:00:00Z

Content type: tutorial

Language: en

Sources: [Dave Leeds on Kotlin - typealias.com](<https://devfeed.tech/sources/dave-leeds-on-kotlin-typealias-com.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [interfaces](<https://devfeed.tech/topics/interfaces.md>)

Tags: [abstract-class](<https://devfeed.tech/tags/abstract-class.md>), [classes](<https://devfeed.tech/tags/classes.md>), [compare](<https://devfeed.tech/tags/compare.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [extend](<https://devfeed.tech/tags/extend.md>), [function](<https://devfeed.tech/tags/function.md>), [implement](<https://devfeed.tech/tags/implement.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [interface](<https://devfeed.tech/tags/interface.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [introduction](<https://devfeed.tech/tags/introduction.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [learn-to-program](<https://devfeed.tech/tags/learn-to-program.md>), [open-class](<https://devfeed.tech/tags/open-class.md>), [polymorphism](<https://devfeed.tech/tags/polymorphism.md>), [programming](<https://devfeed.tech/tags/programming.md>), [retro](<https://devfeed.tech/tags/retro.md>), [speed](<https://devfeed.tech/tags/speed.md>), [subclass](<https://devfeed.tech/tags/subclass.md>), [superclass](<https://devfeed.tech/tags/superclass.md>)

### AI overview

A tutorial chapter explaining how to extend open and abstract classes to create subtypes and share general code. It compares this approach with interfaces and delegation, highlighting that each has advantages and disadvantages.

### Source excerpt

In Chapter 12, we saw how we could use interfaces to create subtypes, and in the last chapter, we saw how we could use delegation with interfaces in order to share general code among specific classes. In this chapter, we'll learn how we can extend open and abstract classes to accomplish these same things with a different approach. Each approach has its advantages and disadvantages, so we'll also look at how they compare to one another.

## Using the Eisenhower Matrix to Manage Overwhelm

DevFeed: [Using the Eisenhower Matrix to Manage Overwhelm](<https://devfeed.tech/articles/imperfect-12-overcoming-overwhelm-39450.md>)

Original publisher: [Read original article](<https://imperfect.substack.com/p/imperfect-12-overcoming-overwhelm>)

Author: Pedro Gil Carvalho

Published: 2023-06-23T06:46:57Z

Content type: opinion

Language: en

Sources: [Pedro Gil Carvalho](<https://devfeed.tech/sources/pedro-gil-carvalho.md>)

Topics: [Matrix](<https://devfeed.tech/topics/matrix-org.md>), [systems](<https://devfeed.tech/topics/systems.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [meetings](<https://devfeed.tech/topics/meetings.md>)

Tags: [delegation](<https://devfeed.tech/tags/delegation.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [meetings](<https://devfeed.tech/tags/meetings.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

The author describes using management systems to handle recurring problems and reduce decision-making overhead. When competing priorities become overwhelming, they use the Eisenhower Matrix to classify tasks by urgency and importance, identify delegation opportunities, and review priorities on a Miro board.

### Source excerpt

How the Eisenhower Matrix saves my day

## Interface Delegation

DevFeed: [Interface Delegation](<https://devfeed.tech/articles/interface-delegation-39200.md>)

Original publisher: [Read original article](<https://kt.academy/article/ak-interface-delegation>)

Published: 2023-03-06T00:15:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [interface](<https://devfeed.tech/topics/interface.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>)

Tags: [delegates](<https://devfeed.tech/tags/delegates.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [interface](<https://devfeed.tech/tags/interface.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [safety](<https://devfeed.tech/tags/safety.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This tutorial explains Kotlin interface delegation through the delegation pattern, composition, and comparison with inheritance. It describes how delegation reuses implementations, supports polymorphic behavior, and reduces the additional code needed when specifying a delegate.

### Source excerpt

One of the least known Kotlin features, that can be sometimes found really useful.

## Introduction to Class Delegation

DevFeed: [Introduction to Class Delegation](<https://devfeed.tech/articles/introduction-to-class-delegation-25053.md>)

Original publisher: [Read original article](<https://typealias.com/start/kotlin-delegation/>)

Author: author@typealias.com (Dave Leeds)

Published: 2023-02-06T00:00:00Z

Content type: tutorial

Language: en

Sources: [Dave Leeds on Kotlin - typealias.com](<https://devfeed.tech/sources/dave-leeds-on-kotlin-typealias-com.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Code](<https://devfeed.tech/topics/code.md>), [interfaces](<https://devfeed.tech/topics/interfaces.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [introduction](<https://devfeed.tech/tags/introduction.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [learn-to-program](<https://devfeed.tech/tags/learn-to-program.md>), [override](<https://devfeed.tech/tags/override.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

A tutorial introducing Kotlin class delegation. It explains how interfaces and delegation let classes reuse functions and properties, using a restaurant waiter-and-chef analogy before modeling the relationship in Kotlin.

### Source excerpt

Back in Chapter 2, we introduced functions as a way to prevent us from duplicating expressions. Once we start working with classes, we might notice that it's also possible to end up duplicating our functions. There are lots of ways to reuse our functions instead of duplicating them. In this chapter, we'll see how we can use interfaces with Kotlin's class delegation feature to reuse the code from our functions and properties.

## Kotlin property delegates for Datastore Preferences library

DevFeed: [Kotlin property delegates for Datastore Preferences library](<https://devfeed.tech/articles/kotlin-property-delegates-for-datastore-preferences-library-26020.md>)

Original publisher: [Read original article](<https://proandroiddev.com/kotlin-property-delegates-for-datastore-preferences-library-5d4e1cdb609b?source=rss-e93d234beac6------2>)

Author: Yahor Urbanovich

Published: 2021-08-23T15:40:08Z

Content type: tutorial

Language: en

Sources: [Stories by Yahor Urbanovich on Medium](<https://devfeed.tech/sources/stories-by-yahor-urbanovich-on-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Library](<https://devfeed.tech/topics/library.md>), [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [kotlin-flow](<https://devfeed.tech/topics/kotlin-flow.md>), [migration](<https://devfeed.tech/topics/migration.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [delegates](<https://devfeed.tech/tags/delegates.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [deprecated](<https://devfeed.tech/tags/deprecated.md>), [flow](<https://devfeed.tech/tags/flow.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-flow](<https://devfeed.tech/tags/kotlin-flow.md>), [library](<https://devfeed.tech/tags/library.md>), [migration](<https://devfeed.tech/tags/migration.md>), [property-delegation](<https://devfeed.tech/tags/property-delegation.md>), [suspend-function](<https://devfeed.tech/tags/suspend-function.md>)

### AI overview

This tutorial explains migrating preference storage from SharedPreferences to AndroidX DataStore Preferences. It shows how Kotlin property delegation can encapsulate reading and writing values, and how Flow, coroutines, first(), and runBlocking can support single-value access despite DataStore's Flow-based API.

### Source excerpt

Kotlin delegated property for Datastore Preferences library Recently AndroidX Datastore 1.0 was released. The moment has come, it's time to migrate away from SharedPreferences. As for me, the key benefit is the built-in support of Kotlin Flow and Coroutines. Previously we had to write our own wrapper under SharedPreferences.OnSharedPreferenceChangeListener, emit changes into ConflatedBroadcastChannel and then convert it into Flow. https://medium.com/media/b5410ce9df08d9b73427a2138a6b0a8d/href Firstly, this approach produces a lot of intermediate variables. Secondly, ConflatedBroadcastChannel deprecated and should be replaced with StateFlow. In this case, DataStore comes out as the winner. The migrated to DataStore version looks clean and simple. https://medium.com/media/cce0d485e2af9941e677dc7973a54c6f/hrefRead/write single value using SharedPreferences Let's imagine, we need to store the current App theme as String. For this purpose, we need to initialize SharedPreferences, then make two functions to read and write these values. https://medium.com/media/3bc9760a22ebd1071e4dcb21eaf8d4ba/href Well, two functions it is not so bad, but we can try to merge this into single Property. https://medium.com/media/c3babbf2b6c55bb18172f66ddc825b06/href To make it fully clear and supportable we can use the Kotlin delegation feature. As we want to read and write simultaneously, ReadWriteProperty will suit our goal. https://medium.com/media/80f370a5a5735b911c75d3a0f1d22b21/href Please take a look at the final compact version, where all logic is encapsulated inside the delegate. https://medium.com/media/39b5311b04373b1f31d3030b8b083587/hrefDataStore Preferences and missing API During migration, it turned out that the library doesn't provide an API for reading a single property. DataStore proposes to use Flow for all cases. Developers are now required to read/write the value in the scope of a suspend function. https://medium.com/media/e7c4e45e239e11bc5082f3997e5280dd/href What was e

## Effective Class Delegation

DevFeed: [Effective Class Delegation](<https://devfeed.tech/articles/effective-class-delegation-27061.md>)

Original publisher: [Read original article](<https://zsmb.co/effective-class-delegation/>)

Author: Márton Braun

Published: 2020-09-29T20:00:00Z

Content type: tutorial

Language: en

Sources: [zsmb.co](<https://devfeed.tech/sources/zsmb-co.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [Java](<https://devfeed.tech/topics/java.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [bytecode](<https://devfeed.tech/tags/bytecode.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [interface](<https://devfeed.tech/tags/interface.md>), [java](<https://devfeed.tech/tags/java.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [marton-braun](<https://devfeed.tech/tags/marton-braun.md>), [override](<https://devfeed.tech/tags/override.md>), [subclass](<https://devfeed.tech/tags/subclass.md>), [superclass](<https://devfeed.tech/tags/superclass.md>), [zsmb](<https://devfeed.tech/tags/zsmb.md>), [zsmb-co](<https://devfeed.tech/tags/zsmb-co.md>), [zsmb13](<https://devfeed.tech/tags/zsmb13.md>), [zsmbco](<https://devfeed.tech/tags/zsmbco.md>)

### AI overview

This tutorial explains how Kotlin class delegation can implement an interface by forwarding calls to a contained object. It contrasts this concise approach with Java solutions motivated by Effective Java's recommendation to favor composition over inheritance.

### Source excerpt

One of the most significant items of the Effective Java book is Item 18: Favor composition over inheritance. Let's see how Kotlin promotes this with class delegation.

## Under the hood of Kotlin Class Delegation

DevFeed: [Under the hood of Kotlin Class Delegation](<https://devfeed.tech/articles/under-the-hood-of-kotlin-class-delegation-25974.md>)

Original publisher: [Read original article](<https://medium.com/snapp-mobile/under-the-hood-of-kotlin-class-delegation-24d53f9aa924?source=rss-8efc0359e234------2>)

Author: Jossi Wolf

Published: 2019-04-09T13:20:12Z

Content type: tutorial

Language: en

Sources: [Stories by Jossi Wolf on Medium](<https://devfeed.tech/sources/stories-by-jossi-wolf-on-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Code](<https://devfeed.tech/topics/code.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [software-development](<https://devfeed.tech/topics/software-development.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [api](<https://devfeed.tech/tags/api.md>), [bytecode](<https://devfeed.tech/tags/bytecode.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [interface](<https://devfeed.tech/tags/interface.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [proxy](<https://devfeed.tech/tags/proxy.md>), [stories](<https://devfeed.tech/tags/stories.md>)

### AI overview

This Kotlin tutorial explains how class delegation can expose an interface through a class without cluttering it with proxy methods. It also describes the generated delegation functions and their effect on compiled code size.

### Source excerpt

I was told to add an image to the post, so here's one Photo by Jf Brou from Unsplash. Bonus points since Samoyeds are some of the cutest dogs out there! A piece of rather popular advice heard in software development is "favour composition over inheritance". I won't go into the details of why as there is an excellent chapter in "Effective Java" about it, as well as this nice article by Eric Lin. This article explores how class delegation can be useful and how it works under the hood. In our case, we had a custom view which should expose an interface looking like this: https://medium.com/media/2efb0d0125ffec7f388ee2df190bcf6a/href Now it was time to create the CanvasCapabilities implementation. https://medium.com/media/3d8b72ac99b28b99f39c95c882a69dce/href Of course, we don't want to start putting logic into our view just for the sake of exposing the interface through it, which meant that the view now had to act as a "proxy" (implementing the interface and calling the ArtboardCanvas ): https://medium.com/media/f3d51d082e7f23d725ef7efafb3fe131/href Not a nice solution, but at least we extracted the logic. The view was still cluttered though :( Class Delegation to the rescue Using the by keyword in Kotlin, properties and even classes can be delegated. You might know it from using lazy : https://medium.com/media/cbea2e6d1363f31e28552d9a8c87823e/href You can also delegate inheritance, which is what we are after. The usage looks like this: https://medium.com/media/5482d423d1b2a0fcff239f25c4ab31e9/href This delegates the methods from CanvasCapabilities to ArtboardCanvas . No more cluttering with "proxy" calls! Under The Hood Under the hood, Kotlin actually doesn't do any "black magic": It just generates a function which invokes the delegate. The bytecode, decompiled to Java looks like this: https://medium.com/media/34cf5d85a4bcf122bc98d74425e9a5dd/href If you have a lot of methods, that code will still be generated and adding to your compiled code's size, but at least it do

## Interfaces in Kotlin. Who said interfaces can't have code? (KAD 26)

DevFeed: [Interfaces in Kotlin. Who said interfaces can't have code? (KAD 26)](<https://devfeed.tech/articles/interfaces-in-kotlin-who-said-interfaces-can-t-have-code-kad-26-27173.md>)

Original publisher: [Read original article](<https://antonioleiva.com/interfaces-kotlin>)

Published: 2017-06-06T00:00:00Z

Content type: tutorial

Language: en

Sources: [Antonio Leiva](<https://devfeed.tech/sources/antonio-leiva.md>)

Topics: [interfaces](<https://devfeed.tech/topics/interfaces.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Code](<https://devfeed.tech/topics/code.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [Java](<https://devfeed.tech/topics/java.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [context](<https://devfeed.tech/tags/context.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [implement](<https://devfeed.tech/tags/implement.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [java](<https://devfeed.tech/tags/java.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>)

### AI overview

This tutorial explains how Kotlin interfaces can include method implementations, enabling code reuse and composition beyond traditional Java interfaces. It also covers the limitation that interfaces cannot retain state and introduces interface delegation.

### Source excerpt

Everything Android, Kotlin and other random topics

## Property delegation in Kotlin: Assign values in Android without having the context (KAD 15)

DevFeed: [Property delegation in Kotlin: Assign values in Android without having the context (KAD 15)](<https://devfeed.tech/articles/property-delegation-in-kotlin-assign-values-in-android-without-having-the-context-kad-15-27216.md>)

Original publisher: [Read original article](<https://antonioleiva.com/property-delegation-kotlin>)

Published: 2017-03-09T00:00:00Z

Content type: tutorial

Language: en

Sources: [Antonio Leiva](<https://devfeed.tech/sources/antonio-leiva.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Android](<https://devfeed.tech/topics/android.md>), [context](<https://devfeed.tech/topics/context.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [adapter](<https://devfeed.tech/tags/adapter.md>), [android](<https://devfeed.tech/tags/android.md>), [context](<https://devfeed.tech/tags/context.md>), [dagger](<https://devfeed.tech/tags/dagger.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [property-delegation](<https://devfeed.tech/tags/property-delegation.md>)

### AI overview

This tutorial explains Kotlin property delegation for Android development, including delaying property initialization when context is unavailable during object creation, lazily assigning a view, observing property changes in an adapter, and declaring a Dagger graph lazily.

### Source excerpt

Everything Android, Kotlin and other random topics

## Securing RubyGems with TUF, Part 2

DevFeed: [Securing RubyGems with TUF, Part 2](<https://devfeed.tech/articles/securing-rubygems-with-tuf-part-2-15841.md>)

Original publisher: [Read original article](<https://developer.squareup.com/blog/securing-rubygems-with-tuf-part-2>)

Author: Square Engineering

Published: 2013-12-09T17:05:00Z

Content type: tutorial

Language: en

Sources: [Square Corner Blog RSS Feed](<https://devfeed.tech/sources/square-corner-blog-rss-feed.md>)

Topics: [rubygems](<https://devfeed.tech/topics/rubygems.md>), [Maintainers](<https://devfeed.tech/topics/maintainers.md>)

Tags: [delegation](<https://devfeed.tech/tags/delegation.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [maintainers](<https://devfeed.tech/tags/maintainers.md>), [offline](<https://devfeed.tech/tags/offline.md>), [private-key](<https://devfeed.tech/tags/private-key.md>), [public-key](<https://devfeed.tech/tags/public-key.md>), [rubygems](<https://devfeed.tech/tags/rubygems.md>), [server](<https://devfeed.tech/tags/server.md>), [uploads](<https://devfeed.tech/tags/uploads.md>)

### AI overview

This second article in a series explains how applying The Update Framework (TUF) to RubyGems can let developers securely update their own gems. Developers sign gem metadata with private keys, while RubyGems maintainers use offline keys during delegation and verification steps.

### Source excerpt

Applying The Update Framework (TUF) to RubyGems to secure it against nefarious activity.