Divide list into batches Three questions: is there a more performant way, is there a more suscinct, strike that, a way of expressing this where if you read just the body it is immediately apperent what the alorithm does, and should I be returning and IEnumerable of an IEnumerable, I mean what would be the point over and IEnumerable of IList?

public static IEnumerable&lt;IEnumerable&lt;T&gt;&gt; IntoBatches&lt;T&gt;(this IEnumerable&lt;T&gt; list, int size)
{
    if (size &lt; 1)
    {
        yield return list;
    }
    else
    {
        var count = 0;
        var batch = new List&lt;T&gt;();
        foreach (var item in list)
        {
            batch.Add(item);
            if (size == ++count)
            {
                yield return batch;
                batch.Clear();
            }
        }
        if (batch.Count &gt; 0) yield return batch;
    }
}
Bug
You have 2 big bugs in your method. The first is that you never ever set the count variable to 0 and the second that you are yielding the List&lt;T&gt;.
If I call your method with a List&lt;int&gt; containing 10000 ints and do a ToList() on the result I get 2 Lists both containing 9997 ints.
Although this is easy to fix like so
public static IEnumerable&lt;IEnumerable&lt;T&gt;&gt; IntoBatches&lt;T&gt;(this IEnumerable&lt;T&gt; list, int size)
{
    if (size &lt; 1)
    {
        yield return list;
    }
    else
    {
        var count = 0;
        foreach (var item in list)
        {
            var batch = new List&lt;T&gt;();                
            batch.Add(item);
            if (size == ++count)
            {
                yield return batch;
                batch = new List&lt;T&gt;();
                count = 0;
            }

        }
        if (batch.Count &gt; 0) yield return batch;
    }
}  

this solution takes for a List&lt;int&gt; having 10000 items with size:
  3: 0.506 ms
 13: 0.505 ms
113: 0.505 ms
  
whereas an array based solution like this (taken from here)
public static IEnumerable&lt;IEnumerable&lt;T&gt;&gt; Chunkify&lt;T&gt;(this IEnumerable&lt;T&gt; source, int size)
{

    using (var iter = source.GetEnumerator())
    {
        while (iter.MoveNext())
        {
            var chunk = new T[size];
            chunk[0] = iter.Current;
            for (int i = 1; i &lt; size &amp;&amp; iter.MoveNext(); i++)
            {
                chunk[i] = iter.Current;
            }
            yield return chunk;
        }
    }
}

takes
  3: 0.270 ms
 13: 0.270 ms
113: 0.270 ms
  
Edit
That Chunkify() method unfortunately has a bug, which is for a passed in IEnumerable&lt;T&gt; with a size which isn't dividable by the passed in chunk size will produce to many items.
E.g passed in a int[] with values 1,2,3,4 and an size argument of 3 will produce 1,2,3,4,0,0.
Fixed version
public static IEnumerable&lt;IEnumerable&lt;T&gt;&gt; Chunkify&lt;T&gt;(this IEnumerable&lt;T&gt; source, int size)
{
    int count = 0;
    using (var iter = source.GetEnumerator())
    {
        while (iter.MoveNext())
        {
            var chunk = new T[size];
            count = 1;
            chunk[0] = iter.Current;
            for (int i = 1; i &lt; size &amp;&amp; iter.MoveNext(); i++)
            {
                chunk[i] = iter.Current;
                count++;
            }
            if (count &lt; size)
            {
                Array.Resize(ref chunk, count);
            }
            yield return chunk;
        }
    }
}